{-# LANGUAGE TypeApplications #-}


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

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

module GI.NM.Objects.SettingWired
    ( 

-- * Exported types
    SettingWired(..)                        ,
    IsSettingWired                          ,
    toSettingWired                          ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addMacBlacklistItem]("GI.NM.Objects.SettingWired#g:method:addMacBlacklistItem"), [addMacDenylistItem]("GI.NM.Objects.SettingWired#g:method:addMacDenylistItem"), [addS390Option]("GI.NM.Objects.SettingWired#g:method:addS390Option"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [clearMacBlacklistItems]("GI.NM.Objects.SettingWired#g:method:clearMacBlacklistItems"), [clearMacDenylistItems]("GI.NM.Objects.SettingWired#g:method:clearMacDenylistItems"), [compare]("GI.NM.Objects.Setting#g:method:compare"), [diff]("GI.NM.Objects.Setting#g:method:diff"), [duplicate]("GI.NM.Objects.Setting#g:method:duplicate"), [enumerateValues]("GI.NM.Objects.Setting#g:method:enumerateValues"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [optionClearByName]("GI.NM.Objects.Setting#g:method:optionClearByName"), [optionGet]("GI.NM.Objects.Setting#g:method:optionGet"), [optionGetAllNames]("GI.NM.Objects.Setting#g:method:optionGetAllNames"), [optionGetBoolean]("GI.NM.Objects.Setting#g:method:optionGetBoolean"), [optionGetUint32]("GI.NM.Objects.Setting#g:method:optionGetUint32"), [optionSet]("GI.NM.Objects.Setting#g:method:optionSet"), [optionSetBoolean]("GI.NM.Objects.Setting#g:method:optionSetBoolean"), [optionSetUint32]("GI.NM.Objects.Setting#g:method:optionSetUint32"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeMacBlacklistItem]("GI.NM.Objects.SettingWired#g:method:removeMacBlacklistItem"), [removeMacBlacklistItemByValue]("GI.NM.Objects.SettingWired#g:method:removeMacBlacklistItemByValue"), [removeMacDenylistItem]("GI.NM.Objects.SettingWired#g:method:removeMacDenylistItem"), [removeMacDenylistItemByValue]("GI.NM.Objects.SettingWired#g:method:removeMacDenylistItemByValue"), [removeS390Option]("GI.NM.Objects.SettingWired#g:method:removeS390Option"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [toString]("GI.NM.Objects.Setting#g:method:toString"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [verify]("GI.NM.Objects.Setting#g:method:verify"), [verifySecrets]("GI.NM.Objects.Setting#g:method:verifySecrets"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAcceptAllMacAddresses]("GI.NM.Objects.SettingWired#g:method:getAcceptAllMacAddresses"), [getAutoNegotiate]("GI.NM.Objects.SettingWired#g:method:getAutoNegotiate"), [getClonedMacAddress]("GI.NM.Objects.SettingWired#g:method:getClonedMacAddress"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDbusPropertyType]("GI.NM.Objects.Setting#g:method:getDbusPropertyType"), [getDuplex]("GI.NM.Objects.SettingWired#g:method:getDuplex"), [getGenerateMacAddressMask]("GI.NM.Objects.SettingWired#g:method:getGenerateMacAddressMask"), [getMacAddress]("GI.NM.Objects.SettingWired#g:method:getMacAddress"), [getMacAddressBlacklist]("GI.NM.Objects.SettingWired#g:method:getMacAddressBlacklist"), [getMacAddressDenylist]("GI.NM.Objects.SettingWired#g:method:getMacAddressDenylist"), [getMacBlacklistItem]("GI.NM.Objects.SettingWired#g:method:getMacBlacklistItem"), [getMacDenylistItem]("GI.NM.Objects.SettingWired#g:method:getMacDenylistItem"), [getMtu]("GI.NM.Objects.SettingWired#g:method:getMtu"), [getName]("GI.NM.Objects.Setting#g:method:getName"), [getNumMacBlacklistItems]("GI.NM.Objects.SettingWired#g:method:getNumMacBlacklistItems"), [getNumMacDenylistItems]("GI.NM.Objects.SettingWired#g:method:getNumMacDenylistItems"), [getNumS390Options]("GI.NM.Objects.SettingWired#g:method:getNumS390Options"), [getPort]("GI.NM.Objects.SettingWired#g:method:getPort"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getS390Nettype]("GI.NM.Objects.SettingWired#g:method:getS390Nettype"), [getS390Option]("GI.NM.Objects.SettingWired#g:method:getS390Option"), [getS390OptionByKey]("GI.NM.Objects.SettingWired#g:method:getS390OptionByKey"), [getS390Subchannels]("GI.NM.Objects.SettingWired#g:method:getS390Subchannels"), [getSecretFlags]("GI.NM.Objects.Setting#g:method:getSecretFlags"), [getSpeed]("GI.NM.Objects.SettingWired#g:method:getSpeed"), [getValidS390Options]("GI.NM.Objects.SettingWired#g:method:getValidS390Options"), [getWakeOnLan]("GI.NM.Objects.SettingWired#g:method:getWakeOnLan"), [getWakeOnLanPassword]("GI.NM.Objects.SettingWired#g:method:getWakeOnLanPassword").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setSecretFlags]("GI.NM.Objects.Setting#g:method:setSecretFlags").

#if defined(ENABLE_OVERLOADING)
    ResolveSettingWiredMethod               ,
#endif

-- ** addMacBlacklistItem #method:addMacBlacklistItem#

#if defined(ENABLE_OVERLOADING)
    SettingWiredAddMacBlacklistItemMethodInfo,
#endif
    settingWiredAddMacBlacklistItem         ,


-- ** addMacDenylistItem #method:addMacDenylistItem#

#if defined(ENABLE_OVERLOADING)
    SettingWiredAddMacDenylistItemMethodInfo,
#endif
    settingWiredAddMacDenylistItem          ,


-- ** addS390Option #method:addS390Option#

#if defined(ENABLE_OVERLOADING)
    SettingWiredAddS390OptionMethodInfo     ,
#endif
    settingWiredAddS390Option               ,


-- ** clearMacBlacklistItems #method:clearMacBlacklistItems#

#if defined(ENABLE_OVERLOADING)
    SettingWiredClearMacBlacklistItemsMethodInfo,
#endif
    settingWiredClearMacBlacklistItems      ,


-- ** clearMacDenylistItems #method:clearMacDenylistItems#

#if defined(ENABLE_OVERLOADING)
    SettingWiredClearMacDenylistItemsMethodInfo,
#endif
    settingWiredClearMacDenylistItems       ,


-- ** getAcceptAllMacAddresses #method:getAcceptAllMacAddresses#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetAcceptAllMacAddressesMethodInfo,
#endif
    settingWiredGetAcceptAllMacAddresses    ,


-- ** getAutoNegotiate #method:getAutoNegotiate#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetAutoNegotiateMethodInfo  ,
#endif
    settingWiredGetAutoNegotiate            ,


-- ** getClonedMacAddress #method:getClonedMacAddress#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetClonedMacAddressMethodInfo,
#endif
    settingWiredGetClonedMacAddress         ,


-- ** getDuplex #method:getDuplex#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetDuplexMethodInfo         ,
#endif
    settingWiredGetDuplex                   ,


-- ** getGenerateMacAddressMask #method:getGenerateMacAddressMask#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetGenerateMacAddressMaskMethodInfo,
#endif
    settingWiredGetGenerateMacAddressMask   ,


-- ** getMacAddress #method:getMacAddress#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetMacAddressMethodInfo     ,
#endif
    settingWiredGetMacAddress               ,


-- ** getMacAddressBlacklist #method:getMacAddressBlacklist#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetMacAddressBlacklistMethodInfo,
#endif
    settingWiredGetMacAddressBlacklist      ,


-- ** getMacAddressDenylist #method:getMacAddressDenylist#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetMacAddressDenylistMethodInfo,
#endif
    settingWiredGetMacAddressDenylist       ,


-- ** getMacBlacklistItem #method:getMacBlacklistItem#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetMacBlacklistItemMethodInfo,
#endif
    settingWiredGetMacBlacklistItem         ,


-- ** getMacDenylistItem #method:getMacDenylistItem#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetMacDenylistItemMethodInfo,
#endif
    settingWiredGetMacDenylistItem          ,


-- ** getMtu #method:getMtu#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetMtuMethodInfo            ,
#endif
    settingWiredGetMtu                      ,


-- ** getNumMacBlacklistItems #method:getNumMacBlacklistItems#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetNumMacBlacklistItemsMethodInfo,
#endif
    settingWiredGetNumMacBlacklistItems     ,


-- ** getNumMacDenylistItems #method:getNumMacDenylistItems#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetNumMacDenylistItemsMethodInfo,
#endif
    settingWiredGetNumMacDenylistItems      ,


-- ** getNumS390Options #method:getNumS390Options#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetNumS390OptionsMethodInfo ,
#endif
    settingWiredGetNumS390Options           ,


-- ** getPort #method:getPort#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetPortMethodInfo           ,
#endif
    settingWiredGetPort                     ,


-- ** getS390Nettype #method:getS390Nettype#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetS390NettypeMethodInfo    ,
#endif
    settingWiredGetS390Nettype              ,


-- ** getS390Option #method:getS390Option#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetS390OptionMethodInfo     ,
#endif
    settingWiredGetS390Option               ,


-- ** getS390OptionByKey #method:getS390OptionByKey#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetS390OptionByKeyMethodInfo,
#endif
    settingWiredGetS390OptionByKey          ,


-- ** getS390Subchannels #method:getS390Subchannels#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetS390SubchannelsMethodInfo,
#endif
    settingWiredGetS390Subchannels          ,


-- ** getSpeed #method:getSpeed#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetSpeedMethodInfo          ,
#endif
    settingWiredGetSpeed                    ,


-- ** getValidS390Options #method:getValidS390Options#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetValidS390OptionsMethodInfo,
#endif
    settingWiredGetValidS390Options         ,


-- ** getWakeOnLan #method:getWakeOnLan#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetWakeOnLanMethodInfo      ,
#endif
    settingWiredGetWakeOnLan                ,


-- ** getWakeOnLanPassword #method:getWakeOnLanPassword#

#if defined(ENABLE_OVERLOADING)
    SettingWiredGetWakeOnLanPasswordMethodInfo,
#endif
    settingWiredGetWakeOnLanPassword        ,


-- ** new #method:new#

    settingWiredNew                         ,


-- ** removeMacBlacklistItem #method:removeMacBlacklistItem#

#if defined(ENABLE_OVERLOADING)
    SettingWiredRemoveMacBlacklistItemMethodInfo,
#endif
    settingWiredRemoveMacBlacklistItem      ,


-- ** removeMacBlacklistItemByValue #method:removeMacBlacklistItemByValue#

#if defined(ENABLE_OVERLOADING)
    SettingWiredRemoveMacBlacklistItemByValueMethodInfo,
#endif
    settingWiredRemoveMacBlacklistItemByValue,


-- ** removeMacDenylistItem #method:removeMacDenylistItem#

#if defined(ENABLE_OVERLOADING)
    SettingWiredRemoveMacDenylistItemMethodInfo,
#endif
    settingWiredRemoveMacDenylistItem       ,


-- ** removeMacDenylistItemByValue #method:removeMacDenylistItemByValue#

#if defined(ENABLE_OVERLOADING)
    SettingWiredRemoveMacDenylistItemByValueMethodInfo,
#endif
    settingWiredRemoveMacDenylistItemByValue,


-- ** removeS390Option #method:removeS390Option#

#if defined(ENABLE_OVERLOADING)
    SettingWiredRemoveS390OptionMethodInfo  ,
#endif
    settingWiredRemoveS390Option            ,




 -- * Properties


-- ** acceptAllMacAddresses #attr:acceptAllMacAddresses#
-- | When 'P.True', setup the interface to accept packets for all MAC addresses.
-- This is enabling the kernel interface flag IFF_PROMISC.
-- When 'P.False', the interface will only accept the packets with the
-- interface destination mac address or broadcast.
-- 
-- /Since: 1.32/

#if defined(ENABLE_OVERLOADING)
    SettingWiredAcceptAllMacAddressesPropertyInfo,
#endif
    constructSettingWiredAcceptAllMacAddresses,
    getSettingWiredAcceptAllMacAddresses    ,
    setSettingWiredAcceptAllMacAddresses    ,
#if defined(ENABLE_OVERLOADING)
    settingWiredAcceptAllMacAddresses       ,
#endif


-- ** autoNegotiate #attr:autoNegotiate#
-- | When 'P.True', enforce auto-negotiation of speed and duplex mode.
-- If \"speed\" and \"duplex\" properties are both specified, only that
-- single mode will be advertised and accepted during the link
-- auto-negotiation process: this works only for BASE-T 802.3 specifications
-- and is useful for enforcing gigabits modes, as in these cases link
-- negotiation is mandatory.
-- When 'P.False', \"speed\" and \"duplex\" properties should be both set or
-- link configuration will be skipped.

#if defined(ENABLE_OVERLOADING)
    SettingWiredAutoNegotiatePropertyInfo   ,
#endif
    constructSettingWiredAutoNegotiate      ,
    getSettingWiredAutoNegotiate            ,
    setSettingWiredAutoNegotiate            ,
#if defined(ENABLE_OVERLOADING)
    settingWiredAutoNegotiate               ,
#endif


-- ** clonedMacAddress #attr:clonedMacAddress#
-- | If specified, request that the device use this MAC address instead.
-- This is known as MAC cloning or spoofing.
-- 
-- Beside explicitly specifying a MAC address, the special values \"preserve\", \"permanent\",
-- \"random\" and \"stable\" are supported.
-- \"preserve\" means not to touch the MAC address on activation.
-- \"permanent\" means to use the permanent hardware address if the device
-- has one (otherwise this is treated as \"preserve\").
-- \"random\" creates a random MAC address on each connect.
-- \"stable\" creates a hashed MAC address based on connection.stable-id and a
-- machine dependent key.
-- 
-- If unspecified, the value can be overwritten via global defaults, see manual
-- of NetworkManager.conf. If still unspecified, it defaults to \"preserve\"
-- (older versions of NetworkManager may use a different default value).
-- 
-- On D-Bus, this field is expressed as \"assigned-mac-address\" or the deprecated
-- \"cloned-mac-address\".

#if defined(ENABLE_OVERLOADING)
    SettingWiredClonedMacAddressPropertyInfo,
#endif
    clearSettingWiredClonedMacAddress       ,
    constructSettingWiredClonedMacAddress   ,
    getSettingWiredClonedMacAddress         ,
    setSettingWiredClonedMacAddress         ,
#if defined(ENABLE_OVERLOADING)
    settingWiredClonedMacAddress            ,
#endif


-- ** duplex #attr:duplex#
-- | When a value is set, either \"half\" or \"full\", configures the device
-- to use the specified duplex mode. If \"auto-negotiate\" is \"yes\" the
-- specified duplex mode will be the only one advertised during link
-- negotiation: this works only for BASE-T 802.3 specifications and is
-- useful for enforcing gigabits modes, as in these cases link negotiation
-- is mandatory.
-- If the value is unset (the default), the link configuration will be
-- either skipped (if \"auto-negotiate\" is \"no\", the default) or will
-- be auto-negotiated (if \"auto-negotiate\" is \"yes\") and the local device
-- will advertise all the supported duplex modes.
-- Must be set together with the \"speed\" property if specified.
-- Before specifying a duplex mode be sure your device supports it.

#if defined(ENABLE_OVERLOADING)
    SettingWiredDuplexPropertyInfo          ,
#endif
    clearSettingWiredDuplex                 ,
    constructSettingWiredDuplex             ,
    getSettingWiredDuplex                   ,
    setSettingWiredDuplex                   ,
#if defined(ENABLE_OVERLOADING)
    settingWiredDuplex                      ,
#endif


-- ** generateMacAddressMask #attr:generateMacAddressMask#
-- | With [SettingWired:clonedMacAddress]("GI.NM.Objects.SettingWired#g:attr:clonedMacAddress") setting \"random\" or \"stable\",
-- by default all bits of the MAC address are scrambled and a locally-administered,
-- unicast MAC address is created. This property allows to specify that certain bits
-- are fixed. Note that the least significant bit of the first MAC address will
-- always be unset to create a unicast MAC address.
-- 
-- If the property is 'P.Nothing', it is eligible to be overwritten by a default
-- connection setting. If the value is still 'P.Nothing' or an empty string, the
-- default is to create a locally-administered, unicast MAC address.
-- 
-- If the value contains one MAC address, this address is used as mask. The set
-- bits of the mask are to be filled with the current MAC address of the device,
-- while the unset bits are subject to randomization.
-- Setting \"FE:FF:FF:00:00:00\" means to preserve the OUI of the current MAC address
-- and only randomize the lower 3 bytes using the \"random\" or \"stable\" algorithm.
-- 
-- If the value contains one additional MAC address after the mask,
-- this address is used instead of the current MAC address to fill the bits
-- that shall not be randomized. For example, a value of
-- \"FE:FF:FF:00:00:00 68:F7:28:00:00:00\" will set the OUI of the MAC address
-- to 68:F7:28, while the lower bits are randomized. A value of
-- \"02:00:00:00:00:00 00:00:00:00:00:00\" will create a fully scrambled
-- globally-administered, burned-in MAC address.
-- 
-- If the value contains more than one additional MAC addresses, one of
-- them is chosen randomly. For example, \"02:00:00:00:00:00 00:00:00:00:00:00 02:00:00:00:00:00\"
-- will create a fully scrambled MAC address, randomly locally or globally
-- administered.

#if defined(ENABLE_OVERLOADING)
    SettingWiredGenerateMacAddressMaskPropertyInfo,
#endif
    clearSettingWiredGenerateMacAddressMask ,
    constructSettingWiredGenerateMacAddressMask,
    getSettingWiredGenerateMacAddressMask   ,
    setSettingWiredGenerateMacAddressMask   ,
#if defined(ENABLE_OVERLOADING)
    settingWiredGenerateMacAddressMask      ,
#endif


-- ** macAddress #attr:macAddress#
-- | If specified, this connection will only apply to the Ethernet device
-- whose permanent MAC address matches. This property does not change the
-- MAC address of the device (i.e. MAC spoofing).

#if defined(ENABLE_OVERLOADING)
    SettingWiredMacAddressPropertyInfo      ,
#endif
    clearSettingWiredMacAddress             ,
    constructSettingWiredMacAddress         ,
    getSettingWiredMacAddress               ,
    setSettingWiredMacAddress               ,
#if defined(ENABLE_OVERLOADING)
    settingWiredMacAddress                  ,
#endif


-- ** macAddressBlacklist #attr:macAddressBlacklist#
-- | If specified, this connection will never apply to the Ethernet device
-- whose permanent MAC address matches an address in the list.  Each MAC
-- address is in the standard hex-digits-and-colons notation
-- (00:11:22:33:44:55).

#if defined(ENABLE_OVERLOADING)
    SettingWiredMacAddressBlacklistPropertyInfo,
#endif
    clearSettingWiredMacAddressBlacklist    ,
    constructSettingWiredMacAddressBlacklist,
    getSettingWiredMacAddressBlacklist      ,
    setSettingWiredMacAddressBlacklist      ,
#if defined(ENABLE_OVERLOADING)
    settingWiredMacAddressBlacklist         ,
#endif


-- ** macAddressDenylist #attr:macAddressDenylist#
-- | If specified, this connection will never apply to the Ethernet device
-- whose permanent MAC address matches an address in the list.  Each MAC
-- address is in the standard hex-digits-and-colons notation
-- (00:11:22:33:44:55).

#if defined(ENABLE_OVERLOADING)
    SettingWiredMacAddressDenylistPropertyInfo,
#endif
    clearSettingWiredMacAddressDenylist     ,
    constructSettingWiredMacAddressDenylist ,
    getSettingWiredMacAddressDenylist       ,
    setSettingWiredMacAddressDenylist       ,
#if defined(ENABLE_OVERLOADING)
    settingWiredMacAddressDenylist          ,
#endif


-- ** mtu #attr:mtu#
-- | If non-zero, only transmit packets of the specified size or smaller,
-- breaking larger packets up into multiple Ethernet frames.

#if defined(ENABLE_OVERLOADING)
    SettingWiredMtuPropertyInfo             ,
#endif
    constructSettingWiredMtu                ,
    getSettingWiredMtu                      ,
    setSettingWiredMtu                      ,
#if defined(ENABLE_OVERLOADING)
    settingWiredMtu                         ,
#endif


-- ** port #attr:port#
-- | Specific port type to use if the device supports multiple
-- attachment methods.  One of \"tp\" (Twisted Pair), \"aui\" (Attachment Unit
-- Interface), \"bnc\" (Thin Ethernet) or \"mii\" (Media Independent Interface).
-- If the device supports only one port type, this setting is ignored.

#if defined(ENABLE_OVERLOADING)
    SettingWiredPortPropertyInfo            ,
#endif
    clearSettingWiredPort                   ,
    constructSettingWiredPort               ,
    getSettingWiredPort                     ,
    setSettingWiredPort                     ,
#if defined(ENABLE_OVERLOADING)
    settingWiredPort                        ,
#endif


-- ** s390Nettype #attr:s390Nettype#
-- | s390 network device type; one of \"qeth\", \"lcs\", or \"ctc\", representing
-- the different types of virtual network devices available on s390 systems.

#if defined(ENABLE_OVERLOADING)
    SettingWiredS390NettypePropertyInfo     ,
#endif
    clearSettingWiredS390Nettype            ,
    constructSettingWiredS390Nettype        ,
    getSettingWiredS390Nettype              ,
    setSettingWiredS390Nettype              ,
#if defined(ENABLE_OVERLOADING)
    settingWiredS390Nettype                 ,
#endif


-- ** s390Options #attr:s390Options#
-- | Dictionary of key\/value pairs of s390-specific device options.  Both keys
-- and values must be strings.  Allowed keys include \"portno\", \"layer2\",
-- \"portname\", \"protocol\", among others.  Key names must contain only
-- alphanumeric characters (ie, [a-zA-Z0-9]).
-- 
-- Currently, NetworkManager itself does nothing with this information.
-- However, s390utils ships a udev rule which parses this information
-- and applies it to the interface.

#if defined(ENABLE_OVERLOADING)
    SettingWiredS390OptionsPropertyInfo     ,
#endif
    clearSettingWiredS390Options            ,
    constructSettingWiredS390Options        ,
    getSettingWiredS390Options              ,
    setSettingWiredS390Options              ,
#if defined(ENABLE_OVERLOADING)
    settingWiredS390Options                 ,
#endif


-- ** s390Subchannels #attr:s390Subchannels#
-- | Identifies specific subchannels that this network device uses for
-- communication with z\/VM or s390 host.  Like the
-- [SettingWired:macAddress]("GI.NM.Objects.SettingWired#g:attr:macAddress") property for non-z\/VM devices, this property
-- can be used to ensure this connection only applies to the network device
-- that uses these subchannels.  The list should contain exactly 3 strings,
-- and each string may only be composed of hexadecimal characters and the
-- period (.) character.

#if defined(ENABLE_OVERLOADING)
    SettingWiredS390SubchannelsPropertyInfo ,
#endif
    clearSettingWiredS390Subchannels        ,
    constructSettingWiredS390Subchannels    ,
    getSettingWiredS390Subchannels          ,
    setSettingWiredS390Subchannels          ,
#if defined(ENABLE_OVERLOADING)
    settingWiredS390Subchannels             ,
#endif


-- ** speed #attr:speed#
-- | When a value greater than 0 is set, configures the device to use
-- the specified speed. If \"auto-negotiate\" is \"yes\" the specified
-- speed will be the only one advertised during link negotiation:
-- this works only for BASE-T 802.3 specifications and is useful for
-- enforcing gigabit speeds, as in this case link negotiation is
-- mandatory.
-- If the value is unset (0, the default), the link configuration will be
-- either skipped (if \"auto-negotiate\" is \"no\", the default) or will
-- be auto-negotiated (if \"auto-negotiate\" is \"yes\") and the local device
-- will advertise all the supported speeds.
-- In Mbit\/s, ie 100 == 100Mbit\/s.
-- Must be set together with the \"duplex\" property when non-zero.
-- Before specifying a speed value be sure your device supports it.

#if defined(ENABLE_OVERLOADING)
    SettingWiredSpeedPropertyInfo           ,
#endif
    constructSettingWiredSpeed              ,
    getSettingWiredSpeed                    ,
    setSettingWiredSpeed                    ,
#if defined(ENABLE_OVERLOADING)
    settingWiredSpeed                       ,
#endif


-- ** wakeOnLan #attr:wakeOnLan#
-- | The t'GI.NM.Flags.SettingWiredWakeOnLan' options to enable. Not all devices support all options.
-- May be any combination of 'GI.NM.Flags.SettingWiredWakeOnLanPhy',
-- 'GI.NM.Flags.SettingWiredWakeOnLanUnicast', 'GI.NM.Flags.SettingWiredWakeOnLanMulticast',
-- 'GI.NM.Flags.SettingWiredWakeOnLanBroadcast', 'GI.NM.Flags.SettingWiredWakeOnLanArp',
-- 'GI.NM.Flags.SettingWiredWakeOnLanMagic' or the special values
-- 'GI.NM.Flags.SettingWiredWakeOnLanDefault' (to use global settings) and
-- 'GI.NM.Flags.SettingWiredWakeOnLanIgnore' (to disable management of Wake-on-LAN in
-- NetworkManager).
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    SettingWiredWakeOnLanPropertyInfo       ,
#endif
    constructSettingWiredWakeOnLan          ,
    getSettingWiredWakeOnLan                ,
    setSettingWiredWakeOnLan                ,
#if defined(ENABLE_OVERLOADING)
    settingWiredWakeOnLan                   ,
#endif


-- ** wakeOnLanPassword #attr:wakeOnLanPassword#
-- | If specified, the password used with magic-packet-based
-- Wake-on-LAN, represented as an Ethernet MAC address.  If 'P.Nothing',
-- no password will be required.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    SettingWiredWakeOnLanPasswordPropertyInfo,
#endif
    clearSettingWiredWakeOnLanPassword      ,
    constructSettingWiredWakeOnLanPassword  ,
    getSettingWiredWakeOnLanPassword        ,
    setSettingWiredWakeOnLanPassword        ,
#if defined(ENABLE_OVERLOADING)
    settingWiredWakeOnLanPassword           ,
#endif




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.VariantType as GLib.VariantType
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.NM.Callbacks as NM.Callbacks
import {-# SOURCE #-} qualified GI.NM.Enums as NM.Enums
import {-# SOURCE #-} qualified GI.NM.Flags as NM.Flags
import {-# SOURCE #-} qualified GI.NM.Interfaces.Connection as NM.Connection
import {-# SOURCE #-} qualified GI.NM.Objects.Setting as NM.Setting
import {-# SOURCE #-} qualified GI.NM.Objects.Setting8021x as NM.Setting8021x
import {-# SOURCE #-} qualified GI.NM.Objects.SettingAdsl as NM.SettingAdsl
import {-# SOURCE #-} qualified GI.NM.Objects.SettingBluetooth as NM.SettingBluetooth
import {-# SOURCE #-} qualified GI.NM.Objects.SettingBond as NM.SettingBond
import {-# SOURCE #-} qualified GI.NM.Objects.SettingBridge as NM.SettingBridge
import {-# SOURCE #-} qualified GI.NM.Objects.SettingBridgePort as NM.SettingBridgePort
import {-# SOURCE #-} qualified GI.NM.Objects.SettingCdma as NM.SettingCdma
import {-# SOURCE #-} qualified GI.NM.Objects.SettingConnection as NM.SettingConnection
import {-# SOURCE #-} qualified GI.NM.Objects.SettingDcb as NM.SettingDcb
import {-# SOURCE #-} qualified GI.NM.Objects.SettingDummy as NM.SettingDummy
import {-# SOURCE #-} qualified GI.NM.Objects.SettingGeneric as NM.SettingGeneric
import {-# SOURCE #-} qualified GI.NM.Objects.SettingGsm as NM.SettingGsm
import {-# SOURCE #-} qualified GI.NM.Objects.SettingIP4Config as NM.SettingIP4Config
import {-# SOURCE #-} qualified GI.NM.Objects.SettingIP6Config as NM.SettingIP6Config
import {-# SOURCE #-} qualified GI.NM.Objects.SettingIPConfig as NM.SettingIPConfig
import {-# SOURCE #-} qualified GI.NM.Objects.SettingIPTunnel as NM.SettingIPTunnel
import {-# SOURCE #-} qualified GI.NM.Objects.SettingInfiniband as NM.SettingInfiniband
import {-# SOURCE #-} qualified GI.NM.Objects.SettingMacsec as NM.SettingMacsec
import {-# SOURCE #-} qualified GI.NM.Objects.SettingMacvlan as NM.SettingMacvlan
import {-# SOURCE #-} qualified GI.NM.Objects.SettingOlpcMesh as NM.SettingOlpcMesh
import {-# SOURCE #-} qualified GI.NM.Objects.SettingOvsBridge as NM.SettingOvsBridge
import {-# SOURCE #-} qualified GI.NM.Objects.SettingOvsInterface as NM.SettingOvsInterface
import {-# SOURCE #-} qualified GI.NM.Objects.SettingOvsPatch as NM.SettingOvsPatch
import {-# SOURCE #-} qualified GI.NM.Objects.SettingOvsPort as NM.SettingOvsPort
import {-# SOURCE #-} qualified GI.NM.Objects.SettingPpp as NM.SettingPpp
import {-# SOURCE #-} qualified GI.NM.Objects.SettingPppoe as NM.SettingPppoe
import {-# SOURCE #-} qualified GI.NM.Objects.SettingProxy as NM.SettingProxy
import {-# SOURCE #-} qualified GI.NM.Objects.SettingSerial as NM.SettingSerial
import {-# SOURCE #-} qualified GI.NM.Objects.SettingTCConfig as NM.SettingTCConfig
import {-# SOURCE #-} qualified GI.NM.Objects.SettingTeam as NM.SettingTeam
import {-# SOURCE #-} qualified GI.NM.Objects.SettingTeamPort as NM.SettingTeamPort
import {-# SOURCE #-} qualified GI.NM.Objects.SettingTun as NM.SettingTun
import {-# SOURCE #-} qualified GI.NM.Objects.SettingVlan as NM.SettingVlan
import {-# SOURCE #-} qualified GI.NM.Objects.SettingVpn as NM.SettingVpn
import {-# SOURCE #-} qualified GI.NM.Objects.SettingVxlan as NM.SettingVxlan
import {-# SOURCE #-} qualified GI.NM.Objects.SettingWimax as NM.SettingWimax
import {-# SOURCE #-} qualified GI.NM.Objects.SettingWireless as NM.SettingWireless
import {-# SOURCE #-} qualified GI.NM.Objects.SettingWirelessSecurity as NM.SettingWirelessSecurity
import {-# SOURCE #-} qualified GI.NM.Structs.BridgeVlan as NM.BridgeVlan
import {-# SOURCE #-} qualified GI.NM.Structs.IPAddress as NM.IPAddress
import {-# SOURCE #-} qualified GI.NM.Structs.IPRoute as NM.IPRoute
import {-# SOURCE #-} qualified GI.NM.Structs.IPRoutingRule as NM.IPRoutingRule
import {-# SOURCE #-} qualified GI.NM.Structs.Range as NM.Range
import {-# SOURCE #-} qualified GI.NM.Structs.TCAction as NM.TCAction
import {-# SOURCE #-} qualified GI.NM.Structs.TCQdisc as NM.TCQdisc
import {-# SOURCE #-} qualified GI.NM.Structs.TCTfilter as NM.TCTfilter
import {-# SOURCE #-} qualified GI.NM.Structs.TeamLinkWatcher as NM.TeamLinkWatcher
import {-# SOURCE #-} qualified GI.NM.Structs.VariantAttributeSpec as NM.VariantAttributeSpec

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

#endif

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

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

foreign import ccall "nm_setting_wired_get_type"
    c_nm_setting_wired_get_type :: IO B.Types.GType

instance B.Types.TypedObject SettingWired where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_wired_get_type

instance B.Types.GObject SettingWired

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

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

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveSettingWiredMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveSettingWiredMethod "addMacBlacklistItem" o = SettingWiredAddMacBlacklistItemMethodInfo
    ResolveSettingWiredMethod "addMacDenylistItem" o = SettingWiredAddMacDenylistItemMethodInfo
    ResolveSettingWiredMethod "addS390Option" o = SettingWiredAddS390OptionMethodInfo
    ResolveSettingWiredMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveSettingWiredMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveSettingWiredMethod "clearMacBlacklistItems" o = SettingWiredClearMacBlacklistItemsMethodInfo
    ResolveSettingWiredMethod "clearMacDenylistItems" o = SettingWiredClearMacDenylistItemsMethodInfo
    ResolveSettingWiredMethod "compare" o = NM.Setting.SettingCompareMethodInfo
    ResolveSettingWiredMethod "diff" o = NM.Setting.SettingDiffMethodInfo
    ResolveSettingWiredMethod "duplicate" o = NM.Setting.SettingDuplicateMethodInfo
    ResolveSettingWiredMethod "enumerateValues" o = NM.Setting.SettingEnumerateValuesMethodInfo
    ResolveSettingWiredMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveSettingWiredMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveSettingWiredMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveSettingWiredMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveSettingWiredMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveSettingWiredMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveSettingWiredMethod "optionClearByName" o = NM.Setting.SettingOptionClearByNameMethodInfo
    ResolveSettingWiredMethod "optionGet" o = NM.Setting.SettingOptionGetMethodInfo
    ResolveSettingWiredMethod "optionGetAllNames" o = NM.Setting.SettingOptionGetAllNamesMethodInfo
    ResolveSettingWiredMethod "optionGetBoolean" o = NM.Setting.SettingOptionGetBooleanMethodInfo
    ResolveSettingWiredMethod "optionGetUint32" o = NM.Setting.SettingOptionGetUint32MethodInfo
    ResolveSettingWiredMethod "optionSet" o = NM.Setting.SettingOptionSetMethodInfo
    ResolveSettingWiredMethod "optionSetBoolean" o = NM.Setting.SettingOptionSetBooleanMethodInfo
    ResolveSettingWiredMethod "optionSetUint32" o = NM.Setting.SettingOptionSetUint32MethodInfo
    ResolveSettingWiredMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveSettingWiredMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveSettingWiredMethod "removeMacBlacklistItem" o = SettingWiredRemoveMacBlacklistItemMethodInfo
    ResolveSettingWiredMethod "removeMacBlacklistItemByValue" o = SettingWiredRemoveMacBlacklistItemByValueMethodInfo
    ResolveSettingWiredMethod "removeMacDenylistItem" o = SettingWiredRemoveMacDenylistItemMethodInfo
    ResolveSettingWiredMethod "removeMacDenylistItemByValue" o = SettingWiredRemoveMacDenylistItemByValueMethodInfo
    ResolveSettingWiredMethod "removeS390Option" o = SettingWiredRemoveS390OptionMethodInfo
    ResolveSettingWiredMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveSettingWiredMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveSettingWiredMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveSettingWiredMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveSettingWiredMethod "toString" o = NM.Setting.SettingToStringMethodInfo
    ResolveSettingWiredMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveSettingWiredMethod "verify" o = NM.Setting.SettingVerifyMethodInfo
    ResolveSettingWiredMethod "verifySecrets" o = NM.Setting.SettingVerifySecretsMethodInfo
    ResolveSettingWiredMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveSettingWiredMethod "getAcceptAllMacAddresses" o = SettingWiredGetAcceptAllMacAddressesMethodInfo
    ResolveSettingWiredMethod "getAutoNegotiate" o = SettingWiredGetAutoNegotiateMethodInfo
    ResolveSettingWiredMethod "getClonedMacAddress" o = SettingWiredGetClonedMacAddressMethodInfo
    ResolveSettingWiredMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveSettingWiredMethod "getDbusPropertyType" o = NM.Setting.SettingGetDbusPropertyTypeMethodInfo
    ResolveSettingWiredMethod "getDuplex" o = SettingWiredGetDuplexMethodInfo
    ResolveSettingWiredMethod "getGenerateMacAddressMask" o = SettingWiredGetGenerateMacAddressMaskMethodInfo
    ResolveSettingWiredMethod "getMacAddress" o = SettingWiredGetMacAddressMethodInfo
    ResolveSettingWiredMethod "getMacAddressBlacklist" o = SettingWiredGetMacAddressBlacklistMethodInfo
    ResolveSettingWiredMethod "getMacAddressDenylist" o = SettingWiredGetMacAddressDenylistMethodInfo
    ResolveSettingWiredMethod "getMacBlacklistItem" o = SettingWiredGetMacBlacklistItemMethodInfo
    ResolveSettingWiredMethod "getMacDenylistItem" o = SettingWiredGetMacDenylistItemMethodInfo
    ResolveSettingWiredMethod "getMtu" o = SettingWiredGetMtuMethodInfo
    ResolveSettingWiredMethod "getName" o = NM.Setting.SettingGetNameMethodInfo
    ResolveSettingWiredMethod "getNumMacBlacklistItems" o = SettingWiredGetNumMacBlacklistItemsMethodInfo
    ResolveSettingWiredMethod "getNumMacDenylistItems" o = SettingWiredGetNumMacDenylistItemsMethodInfo
    ResolveSettingWiredMethod "getNumS390Options" o = SettingWiredGetNumS390OptionsMethodInfo
    ResolveSettingWiredMethod "getPort" o = SettingWiredGetPortMethodInfo
    ResolveSettingWiredMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveSettingWiredMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveSettingWiredMethod "getS390Nettype" o = SettingWiredGetS390NettypeMethodInfo
    ResolveSettingWiredMethod "getS390Option" o = SettingWiredGetS390OptionMethodInfo
    ResolveSettingWiredMethod "getS390OptionByKey" o = SettingWiredGetS390OptionByKeyMethodInfo
    ResolveSettingWiredMethod "getS390Subchannels" o = SettingWiredGetS390SubchannelsMethodInfo
    ResolveSettingWiredMethod "getSecretFlags" o = NM.Setting.SettingGetSecretFlagsMethodInfo
    ResolveSettingWiredMethod "getSpeed" o = SettingWiredGetSpeedMethodInfo
    ResolveSettingWiredMethod "getValidS390Options" o = SettingWiredGetValidS390OptionsMethodInfo
    ResolveSettingWiredMethod "getWakeOnLan" o = SettingWiredGetWakeOnLanMethodInfo
    ResolveSettingWiredMethod "getWakeOnLanPassword" o = SettingWiredGetWakeOnLanPasswordMethodInfo
    ResolveSettingWiredMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveSettingWiredMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveSettingWiredMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveSettingWiredMethod "setSecretFlags" o = NM.Setting.SettingSetSecretFlagsMethodInfo
    ResolveSettingWiredMethod l o = O.MethodResolutionFailed l o

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

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

#endif

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

#endif

-- VVV Prop "accept-all-mac-addresses"
   -- Type: TInterface (Name {namespace = "NM", name = "Ternary"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@accept-all-mac-addresses@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingWired #acceptAllMacAddresses
-- @
getSettingWiredAcceptAllMacAddresses :: (MonadIO m, IsSettingWired o) => o -> m NM.Enums.Ternary
getSettingWiredAcceptAllMacAddresses :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> m Ternary
getSettingWiredAcceptAllMacAddresses o
obj = IO Ternary -> m Ternary
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Ternary -> m Ternary) -> IO Ternary -> m Ternary
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Ternary
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"accept-all-mac-addresses"

-- | Set the value of the “@accept-all-mac-addresses@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingWired [ #acceptAllMacAddresses 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingWiredAcceptAllMacAddresses :: (MonadIO m, IsSettingWired o) => o -> NM.Enums.Ternary -> m ()
setSettingWiredAcceptAllMacAddresses :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> Ternary -> m ()
setSettingWiredAcceptAllMacAddresses o
obj Ternary
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Ternary -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"accept-all-mac-addresses" Ternary
val

-- | Construct a t'GValueConstruct' with valid value for the “@accept-all-mac-addresses@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingWiredAcceptAllMacAddresses :: (IsSettingWired o, MIO.MonadIO m) => NM.Enums.Ternary -> m (GValueConstruct o)
constructSettingWiredAcceptAllMacAddresses :: forall o (m :: * -> *).
(IsSettingWired o, MonadIO m) =>
Ternary -> m (GValueConstruct o)
constructSettingWiredAcceptAllMacAddresses Ternary
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Ternary -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"accept-all-mac-addresses" Ternary
val

#if defined(ENABLE_OVERLOADING)
data SettingWiredAcceptAllMacAddressesPropertyInfo
instance AttrInfo SettingWiredAcceptAllMacAddressesPropertyInfo where
    type AttrAllowedOps SettingWiredAcceptAllMacAddressesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SettingWiredAcceptAllMacAddressesPropertyInfo = IsSettingWired
    type AttrSetTypeConstraint SettingWiredAcceptAllMacAddressesPropertyInfo = (~) NM.Enums.Ternary
    type AttrTransferTypeConstraint SettingWiredAcceptAllMacAddressesPropertyInfo = (~) NM.Enums.Ternary
    type AttrTransferType SettingWiredAcceptAllMacAddressesPropertyInfo = NM.Enums.Ternary
    type AttrGetType SettingWiredAcceptAllMacAddressesPropertyInfo = NM.Enums.Ternary
    type AttrLabel SettingWiredAcceptAllMacAddressesPropertyInfo = "accept-all-mac-addresses"
    type AttrOrigin SettingWiredAcceptAllMacAddressesPropertyInfo = SettingWired
    attrGet = getSettingWiredAcceptAllMacAddresses
    attrSet = setSettingWiredAcceptAllMacAddresses
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingWiredAcceptAllMacAddresses
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingWired.acceptAllMacAddresses"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingWired.html#g:attr:acceptAllMacAddresses"
        })
#endif

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

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

-- | Set the value of the “@auto-negotiate@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingWired [ #autoNegotiate 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingWiredAutoNegotiate :: (MonadIO m, IsSettingWired o) => o -> Bool -> m ()
setSettingWiredAutoNegotiate :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> Bool -> m ()
setSettingWiredAutoNegotiate o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"auto-negotiate" Bool
val

-- | Construct a t'GValueConstruct' with valid value for the “@auto-negotiate@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingWiredAutoNegotiate :: (IsSettingWired o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSettingWiredAutoNegotiate :: forall o (m :: * -> *).
(IsSettingWired o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSettingWiredAutoNegotiate Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"auto-negotiate" Bool
val

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

-- VVV Prop "cloned-mac-address"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@cloned-mac-address@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingWired #clonedMacAddress
-- @
getSettingWiredClonedMacAddress :: (MonadIO m, IsSettingWired o) => o -> m T.Text
getSettingWiredClonedMacAddress :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> m Text
getSettingWiredClonedMacAddress o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getSettingWiredClonedMacAddress" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"cloned-mac-address"

-- | Set the value of the “@cloned-mac-address@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingWired [ #clonedMacAddress 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingWiredClonedMacAddress :: (MonadIO m, IsSettingWired o) => o -> T.Text -> m ()
setSettingWiredClonedMacAddress :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> Text -> m ()
setSettingWiredClonedMacAddress o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"cloned-mac-address" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a t'GValueConstruct' with valid value for the “@cloned-mac-address@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingWiredClonedMacAddress :: (IsSettingWired o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructSettingWiredClonedMacAddress :: forall o (m :: * -> *).
(IsSettingWired o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructSettingWiredClonedMacAddress Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"cloned-mac-address" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@cloned-mac-address@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #clonedMacAddress
-- @
clearSettingWiredClonedMacAddress :: (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredClonedMacAddress :: forall (m :: * -> *) o. (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredClonedMacAddress o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"cloned-mac-address" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data SettingWiredClonedMacAddressPropertyInfo
instance AttrInfo SettingWiredClonedMacAddressPropertyInfo where
    type AttrAllowedOps SettingWiredClonedMacAddressPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SettingWiredClonedMacAddressPropertyInfo = IsSettingWired
    type AttrSetTypeConstraint SettingWiredClonedMacAddressPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint SettingWiredClonedMacAddressPropertyInfo = (~) T.Text
    type AttrTransferType SettingWiredClonedMacAddressPropertyInfo = T.Text
    type AttrGetType SettingWiredClonedMacAddressPropertyInfo = T.Text
    type AttrLabel SettingWiredClonedMacAddressPropertyInfo = "cloned-mac-address"
    type AttrOrigin SettingWiredClonedMacAddressPropertyInfo = SettingWired
    attrGet = getSettingWiredClonedMacAddress
    attrSet = setSettingWiredClonedMacAddress
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingWiredClonedMacAddress
    attrClear = clearSettingWiredClonedMacAddress
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingWired.clonedMacAddress"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingWired.html#g:attr:clonedMacAddress"
        })
#endif

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

-- | Get the value of the “@duplex@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingWired #duplex
-- @
getSettingWiredDuplex :: (MonadIO m, IsSettingWired o) => o -> m T.Text
getSettingWiredDuplex :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> m Text
getSettingWiredDuplex o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getSettingWiredDuplex" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"duplex"

-- | Set the value of the “@duplex@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingWired [ #duplex 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingWiredDuplex :: (MonadIO m, IsSettingWired o) => o -> T.Text -> m ()
setSettingWiredDuplex :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> Text -> m ()
setSettingWiredDuplex o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"duplex" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a t'GValueConstruct' with valid value for the “@duplex@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingWiredDuplex :: (IsSettingWired o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructSettingWiredDuplex :: forall o (m :: * -> *).
(IsSettingWired o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructSettingWiredDuplex Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"duplex" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@duplex@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #duplex
-- @
clearSettingWiredDuplex :: (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredDuplex :: forall (m :: * -> *) o. (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredDuplex o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"duplex" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data SettingWiredDuplexPropertyInfo
instance AttrInfo SettingWiredDuplexPropertyInfo where
    type AttrAllowedOps SettingWiredDuplexPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SettingWiredDuplexPropertyInfo = IsSettingWired
    type AttrSetTypeConstraint SettingWiredDuplexPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint SettingWiredDuplexPropertyInfo = (~) T.Text
    type AttrTransferType SettingWiredDuplexPropertyInfo = T.Text
    type AttrGetType SettingWiredDuplexPropertyInfo = T.Text
    type AttrLabel SettingWiredDuplexPropertyInfo = "duplex"
    type AttrOrigin SettingWiredDuplexPropertyInfo = SettingWired
    attrGet = getSettingWiredDuplex
    attrSet = setSettingWiredDuplex
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingWiredDuplex
    attrClear = clearSettingWiredDuplex
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingWired.duplex"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingWired.html#g:attr:duplex"
        })
#endif

-- VVV Prop "generate-mac-address-mask"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@generate-mac-address-mask@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingWired #generateMacAddressMask
-- @
getSettingWiredGenerateMacAddressMask :: (MonadIO m, IsSettingWired o) => o -> m T.Text
getSettingWiredGenerateMacAddressMask :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> m Text
getSettingWiredGenerateMacAddressMask o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getSettingWiredGenerateMacAddressMask" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"generate-mac-address-mask"

-- | Set the value of the “@generate-mac-address-mask@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingWired [ #generateMacAddressMask 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingWiredGenerateMacAddressMask :: (MonadIO m, IsSettingWired o) => o -> T.Text -> m ()
setSettingWiredGenerateMacAddressMask :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> Text -> m ()
setSettingWiredGenerateMacAddressMask o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"generate-mac-address-mask" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a t'GValueConstruct' with valid value for the “@generate-mac-address-mask@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingWiredGenerateMacAddressMask :: (IsSettingWired o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructSettingWiredGenerateMacAddressMask :: forall o (m :: * -> *).
(IsSettingWired o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructSettingWiredGenerateMacAddressMask Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"generate-mac-address-mask" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@generate-mac-address-mask@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #generateMacAddressMask
-- @
clearSettingWiredGenerateMacAddressMask :: (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredGenerateMacAddressMask :: forall (m :: * -> *) o. (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredGenerateMacAddressMask o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"generate-mac-address-mask" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data SettingWiredGenerateMacAddressMaskPropertyInfo
instance AttrInfo SettingWiredGenerateMacAddressMaskPropertyInfo where
    type AttrAllowedOps SettingWiredGenerateMacAddressMaskPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SettingWiredGenerateMacAddressMaskPropertyInfo = IsSettingWired
    type AttrSetTypeConstraint SettingWiredGenerateMacAddressMaskPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint SettingWiredGenerateMacAddressMaskPropertyInfo = (~) T.Text
    type AttrTransferType SettingWiredGenerateMacAddressMaskPropertyInfo = T.Text
    type AttrGetType SettingWiredGenerateMacAddressMaskPropertyInfo = T.Text
    type AttrLabel SettingWiredGenerateMacAddressMaskPropertyInfo = "generate-mac-address-mask"
    type AttrOrigin SettingWiredGenerateMacAddressMaskPropertyInfo = SettingWired
    attrGet = getSettingWiredGenerateMacAddressMask
    attrSet = setSettingWiredGenerateMacAddressMask
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingWiredGenerateMacAddressMask
    attrClear = clearSettingWiredGenerateMacAddressMask
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingWired.generateMacAddressMask"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingWired.html#g:attr:generateMacAddressMask"
        })
#endif

-- VVV Prop "mac-address"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@mac-address@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingWired #macAddress
-- @
getSettingWiredMacAddress :: (MonadIO m, IsSettingWired o) => o -> m T.Text
getSettingWiredMacAddress :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> m Text
getSettingWiredMacAddress o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getSettingWiredMacAddress" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"mac-address"

-- | Set the value of the “@mac-address@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingWired [ #macAddress 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingWiredMacAddress :: (MonadIO m, IsSettingWired o) => o -> T.Text -> m ()
setSettingWiredMacAddress :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> Text -> m ()
setSettingWiredMacAddress o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"mac-address" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a t'GValueConstruct' with valid value for the “@mac-address@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingWiredMacAddress :: (IsSettingWired o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructSettingWiredMacAddress :: forall o (m :: * -> *).
(IsSettingWired o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructSettingWiredMacAddress Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"mac-address" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@mac-address@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #macAddress
-- @
clearSettingWiredMacAddress :: (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredMacAddress :: forall (m :: * -> *) o. (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredMacAddress o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"mac-address" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data SettingWiredMacAddressPropertyInfo
instance AttrInfo SettingWiredMacAddressPropertyInfo where
    type AttrAllowedOps SettingWiredMacAddressPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SettingWiredMacAddressPropertyInfo = IsSettingWired
    type AttrSetTypeConstraint SettingWiredMacAddressPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint SettingWiredMacAddressPropertyInfo = (~) T.Text
    type AttrTransferType SettingWiredMacAddressPropertyInfo = T.Text
    type AttrGetType SettingWiredMacAddressPropertyInfo = T.Text
    type AttrLabel SettingWiredMacAddressPropertyInfo = "mac-address"
    type AttrOrigin SettingWiredMacAddressPropertyInfo = SettingWired
    attrGet = getSettingWiredMacAddress
    attrSet = setSettingWiredMacAddress
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingWiredMacAddress
    attrClear = clearSettingWiredMacAddress
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingWired.macAddress"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingWired.html#g:attr:macAddress"
        })
#endif

-- VVV Prop "mac-address-blacklist"
   -- Type: TCArray True (-1) (-1) (TBasicType TUTF8)
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@mac-address-blacklist@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingWired #macAddressBlacklist
-- @
getSettingWiredMacAddressBlacklist :: (MonadIO m, IsSettingWired o) => o -> m [T.Text]
getSettingWiredMacAddressBlacklist :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> m [Text]
getSettingWiredMacAddressBlacklist o
obj = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe [Text]) -> IO [Text]
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getSettingWiredMacAddressBlacklist" (IO (Maybe [Text]) -> IO [Text]) -> IO (Maybe [Text]) -> IO [Text]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe [Text])
forall a. GObject a => a -> String -> IO (Maybe [Text])
B.Properties.getObjectPropertyStringArray o
obj String
"mac-address-blacklist"

-- | Set the value of the “@mac-address-blacklist@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingWired [ #macAddressBlacklist 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingWiredMacAddressBlacklist :: (MonadIO m, IsSettingWired o) => o -> [T.Text] -> m ()
setSettingWiredMacAddressBlacklist :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> [Text] -> m ()
setSettingWiredMacAddressBlacklist o
obj [Text]
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe [Text] -> IO ()
forall a. GObject a => a -> String -> Maybe [Text] -> IO ()
B.Properties.setObjectPropertyStringArray o
obj String
"mac-address-blacklist" ([Text] -> Maybe [Text]
forall a. a -> Maybe a
Just [Text]
val)

-- | Construct a t'GValueConstruct' with valid value for the “@mac-address-blacklist@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingWiredMacAddressBlacklist :: (IsSettingWired o, MIO.MonadIO m) => [T.Text] -> m (GValueConstruct o)
constructSettingWiredMacAddressBlacklist :: forall o (m :: * -> *).
(IsSettingWired o, MonadIO m) =>
[Text] -> m (GValueConstruct o)
constructSettingWiredMacAddressBlacklist [Text]
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe [Text] -> IO (GValueConstruct o)
forall o. String -> Maybe [Text] -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyStringArray String
"mac-address-blacklist" ([Text] -> Maybe [Text]
forall a. a -> Maybe a
P.Just [Text]
val)

-- | Set the value of the “@mac-address-blacklist@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #macAddressBlacklist
-- @
clearSettingWiredMacAddressBlacklist :: (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredMacAddressBlacklist :: forall (m :: * -> *) o. (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredMacAddressBlacklist o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe [Text] -> IO ()
forall a. GObject a => a -> String -> Maybe [Text] -> IO ()
B.Properties.setObjectPropertyStringArray o
obj String
"mac-address-blacklist" (Maybe [Text]
forall a. Maybe a
Nothing :: Maybe [T.Text])

#if defined(ENABLE_OVERLOADING)
data SettingWiredMacAddressBlacklistPropertyInfo
instance AttrInfo SettingWiredMacAddressBlacklistPropertyInfo where
    type AttrAllowedOps SettingWiredMacAddressBlacklistPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SettingWiredMacAddressBlacklistPropertyInfo = IsSettingWired
    type AttrSetTypeConstraint SettingWiredMacAddressBlacklistPropertyInfo = (~) [T.Text]
    type AttrTransferTypeConstraint SettingWiredMacAddressBlacklistPropertyInfo = (~) [T.Text]
    type AttrTransferType SettingWiredMacAddressBlacklistPropertyInfo = [T.Text]
    type AttrGetType SettingWiredMacAddressBlacklistPropertyInfo = [T.Text]
    type AttrLabel SettingWiredMacAddressBlacklistPropertyInfo = "mac-address-blacklist"
    type AttrOrigin SettingWiredMacAddressBlacklistPropertyInfo = SettingWired
    attrGet = getSettingWiredMacAddressBlacklist
    attrSet = setSettingWiredMacAddressBlacklist
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingWiredMacAddressBlacklist
    attrClear = clearSettingWiredMacAddressBlacklist
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingWired.macAddressBlacklist"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingWired.html#g:attr:macAddressBlacklist"
        })
#endif

-- VVV Prop "mac-address-denylist"
   -- Type: TCArray True (-1) (-1) (TBasicType TUTF8)
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@mac-address-denylist@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingWired #macAddressDenylist
-- @
getSettingWiredMacAddressDenylist :: (MonadIO m, IsSettingWired o) => o -> m [T.Text]
getSettingWiredMacAddressDenylist :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> m [Text]
getSettingWiredMacAddressDenylist o
obj = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe [Text]) -> IO [Text]
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getSettingWiredMacAddressDenylist" (IO (Maybe [Text]) -> IO [Text]) -> IO (Maybe [Text]) -> IO [Text]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe [Text])
forall a. GObject a => a -> String -> IO (Maybe [Text])
B.Properties.getObjectPropertyStringArray o
obj String
"mac-address-denylist"

-- | Set the value of the “@mac-address-denylist@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingWired [ #macAddressDenylist 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingWiredMacAddressDenylist :: (MonadIO m, IsSettingWired o) => o -> [T.Text] -> m ()
setSettingWiredMacAddressDenylist :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> [Text] -> m ()
setSettingWiredMacAddressDenylist o
obj [Text]
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe [Text] -> IO ()
forall a. GObject a => a -> String -> Maybe [Text] -> IO ()
B.Properties.setObjectPropertyStringArray o
obj String
"mac-address-denylist" ([Text] -> Maybe [Text]
forall a. a -> Maybe a
Just [Text]
val)

-- | Construct a t'GValueConstruct' with valid value for the “@mac-address-denylist@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingWiredMacAddressDenylist :: (IsSettingWired o, MIO.MonadIO m) => [T.Text] -> m (GValueConstruct o)
constructSettingWiredMacAddressDenylist :: forall o (m :: * -> *).
(IsSettingWired o, MonadIO m) =>
[Text] -> m (GValueConstruct o)
constructSettingWiredMacAddressDenylist [Text]
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe [Text] -> IO (GValueConstruct o)
forall o. String -> Maybe [Text] -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyStringArray String
"mac-address-denylist" ([Text] -> Maybe [Text]
forall a. a -> Maybe a
P.Just [Text]
val)

-- | Set the value of the “@mac-address-denylist@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #macAddressDenylist
-- @
clearSettingWiredMacAddressDenylist :: (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredMacAddressDenylist :: forall (m :: * -> *) o. (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredMacAddressDenylist o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe [Text] -> IO ()
forall a. GObject a => a -> String -> Maybe [Text] -> IO ()
B.Properties.setObjectPropertyStringArray o
obj String
"mac-address-denylist" (Maybe [Text]
forall a. Maybe a
Nothing :: Maybe [T.Text])

#if defined(ENABLE_OVERLOADING)
data SettingWiredMacAddressDenylistPropertyInfo
instance AttrInfo SettingWiredMacAddressDenylistPropertyInfo where
    type AttrAllowedOps SettingWiredMacAddressDenylistPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SettingWiredMacAddressDenylistPropertyInfo = IsSettingWired
    type AttrSetTypeConstraint SettingWiredMacAddressDenylistPropertyInfo = (~) [T.Text]
    type AttrTransferTypeConstraint SettingWiredMacAddressDenylistPropertyInfo = (~) [T.Text]
    type AttrTransferType SettingWiredMacAddressDenylistPropertyInfo = [T.Text]
    type AttrGetType SettingWiredMacAddressDenylistPropertyInfo = [T.Text]
    type AttrLabel SettingWiredMacAddressDenylistPropertyInfo = "mac-address-denylist"
    type AttrOrigin SettingWiredMacAddressDenylistPropertyInfo = SettingWired
    attrGet = getSettingWiredMacAddressDenylist
    attrSet = setSettingWiredMacAddressDenylist
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingWiredMacAddressDenylist
    attrClear = clearSettingWiredMacAddressDenylist
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingWired.macAddressDenylist"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingWired.html#g:attr:macAddressDenylist"
        })
#endif

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

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

-- | Set the value of the “@mtu@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingWired [ #mtu 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingWiredMtu :: (MonadIO m, IsSettingWired o) => o -> Word32 -> m ()
setSettingWiredMtu :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> Word32 -> m ()
setSettingWiredMtu o
obj Word32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"mtu" Word32
val

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

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

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

-- | Get the value of the “@port@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingWired #port
-- @
getSettingWiredPort :: (MonadIO m, IsSettingWired o) => o -> m T.Text
getSettingWiredPort :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> m Text
getSettingWiredPort o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getSettingWiredPort" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"port"

-- | Set the value of the “@port@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingWired [ #port 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingWiredPort :: (MonadIO m, IsSettingWired o) => o -> T.Text -> m ()
setSettingWiredPort :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> Text -> m ()
setSettingWiredPort o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"port" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a t'GValueConstruct' with valid value for the “@port@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingWiredPort :: (IsSettingWired o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructSettingWiredPort :: forall o (m :: * -> *).
(IsSettingWired o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructSettingWiredPort Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"port" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@port@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #port
-- @
clearSettingWiredPort :: (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredPort :: forall (m :: * -> *) o. (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredPort o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"port" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data SettingWiredPortPropertyInfo
instance AttrInfo SettingWiredPortPropertyInfo where
    type AttrAllowedOps SettingWiredPortPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SettingWiredPortPropertyInfo = IsSettingWired
    type AttrSetTypeConstraint SettingWiredPortPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint SettingWiredPortPropertyInfo = (~) T.Text
    type AttrTransferType SettingWiredPortPropertyInfo = T.Text
    type AttrGetType SettingWiredPortPropertyInfo = T.Text
    type AttrLabel SettingWiredPortPropertyInfo = "port"
    type AttrOrigin SettingWiredPortPropertyInfo = SettingWired
    attrGet = getSettingWiredPort
    attrSet = setSettingWiredPort
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingWiredPort
    attrClear = clearSettingWiredPort
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingWired.port"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingWired.html#g:attr:port"
        })
#endif

-- VVV Prop "s390-nettype"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@s390-nettype@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingWired #s390Nettype
-- @
getSettingWiredS390Nettype :: (MonadIO m, IsSettingWired o) => o -> m T.Text
getSettingWiredS390Nettype :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> m Text
getSettingWiredS390Nettype o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getSettingWiredS390Nettype" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"s390-nettype"

-- | Set the value of the “@s390-nettype@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingWired [ #s390Nettype 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingWiredS390Nettype :: (MonadIO m, IsSettingWired o) => o -> T.Text -> m ()
setSettingWiredS390Nettype :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> Text -> m ()
setSettingWiredS390Nettype o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"s390-nettype" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a t'GValueConstruct' with valid value for the “@s390-nettype@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingWiredS390Nettype :: (IsSettingWired o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructSettingWiredS390Nettype :: forall o (m :: * -> *).
(IsSettingWired o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructSettingWiredS390Nettype Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"s390-nettype" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@s390-nettype@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #s390Nettype
-- @
clearSettingWiredS390Nettype :: (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredS390Nettype :: forall (m :: * -> *) o. (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredS390Nettype o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"s390-nettype" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data SettingWiredS390NettypePropertyInfo
instance AttrInfo SettingWiredS390NettypePropertyInfo where
    type AttrAllowedOps SettingWiredS390NettypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SettingWiredS390NettypePropertyInfo = IsSettingWired
    type AttrSetTypeConstraint SettingWiredS390NettypePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint SettingWiredS390NettypePropertyInfo = (~) T.Text
    type AttrTransferType SettingWiredS390NettypePropertyInfo = T.Text
    type AttrGetType SettingWiredS390NettypePropertyInfo = T.Text
    type AttrLabel SettingWiredS390NettypePropertyInfo = "s390-nettype"
    type AttrOrigin SettingWiredS390NettypePropertyInfo = SettingWired
    attrGet = getSettingWiredS390Nettype
    attrSet = setSettingWiredS390Nettype
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingWiredS390Nettype
    attrClear = clearSettingWiredS390Nettype
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingWired.s390Nettype"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingWired.html#g:attr:s390Nettype"
        })
#endif

-- VVV Prop "s390-options"
   -- Type: TGHash (TBasicType TUTF8) (TBasicType TUTF8)
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@s390-options@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingWired #s390Options
-- @
getSettingWiredS390Options :: (MonadIO m, IsSettingWired o) => o -> m (Maybe (Map.Map T.Text T.Text))
getSettingWiredS390Options :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> m (Maybe (Map Text Text))
getSettingWiredS390Options o
obj = IO (Maybe (Map Text Text)) -> m (Maybe (Map Text Text))
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe (Map Text Text)) -> m (Maybe (Map Text Text)))
-> IO (Maybe (Map Text Text)) -> m (Maybe (Map Text Text))
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe (Map Text Text))
forall a b. GObject a => a -> String -> IO b
B.Properties.getObjectPropertyHash o
obj String
"s390-options"

-- | Set the value of the “@s390-options@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingWired [ #s390Options 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingWiredS390Options :: (MonadIO m, IsSettingWired o) => o -> Map.Map T.Text T.Text -> m ()
setSettingWiredS390Options :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> Map Text Text -> m ()
setSettingWiredS390Options o
obj Map Text Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe (Map Text Text) -> IO ()
forall a b. GObject a => a -> String -> b -> IO ()
B.Properties.setObjectPropertyHash o
obj String
"s390-options" (Map Text Text -> Maybe (Map Text Text)
forall a. a -> Maybe a
Just Map Text Text
val)

-- | Construct a t'GValueConstruct' with valid value for the “@s390-options@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingWiredS390Options :: (IsSettingWired o, MIO.MonadIO m) => Map.Map T.Text T.Text -> m (GValueConstruct o)
constructSettingWiredS390Options :: forall o (m :: * -> *).
(IsSettingWired o, MonadIO m) =>
Map Text Text -> m (GValueConstruct o)
constructSettingWiredS390Options Map Text Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe (Map Text Text) -> IO (GValueConstruct o)
forall b o. String -> b -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyHash String
"s390-options" (Map Text Text -> Maybe (Map Text Text)
forall a. a -> Maybe a
P.Just Map Text Text
val)

-- | Set the value of the “@s390-options@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #s390Options
-- @
clearSettingWiredS390Options :: (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredS390Options :: forall (m :: * -> *) o. (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredS390Options o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe (Map Text Text) -> IO ()
forall a b. GObject a => a -> String -> b -> IO ()
B.Properties.setObjectPropertyHash o
obj String
"s390-options" (Maybe (Map Text Text)
forall a. Maybe a
Nothing :: Maybe (Map.Map T.Text T.Text))

#if defined(ENABLE_OVERLOADING)
data SettingWiredS390OptionsPropertyInfo
instance AttrInfo SettingWiredS390OptionsPropertyInfo where
    type AttrAllowedOps SettingWiredS390OptionsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SettingWiredS390OptionsPropertyInfo = IsSettingWired
    type AttrSetTypeConstraint SettingWiredS390OptionsPropertyInfo = (~) (Map.Map T.Text T.Text)
    type AttrTransferTypeConstraint SettingWiredS390OptionsPropertyInfo = (~) (Map.Map T.Text T.Text)
    type AttrTransferType SettingWiredS390OptionsPropertyInfo = Map.Map T.Text T.Text
    type AttrGetType SettingWiredS390OptionsPropertyInfo = (Maybe (Map.Map T.Text T.Text))
    type AttrLabel SettingWiredS390OptionsPropertyInfo = "s390-options"
    type AttrOrigin SettingWiredS390OptionsPropertyInfo = SettingWired
    attrGet = getSettingWiredS390Options
    attrSet = setSettingWiredS390Options
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingWiredS390Options
    attrClear = clearSettingWiredS390Options
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingWired.s390Options"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingWired.html#g:attr:s390Options"
        })
#endif

-- VVV Prop "s390-subchannels"
   -- Type: TCArray True (-1) (-1) (TBasicType TUTF8)
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@s390-subchannels@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingWired #s390Subchannels
-- @
getSettingWiredS390Subchannels :: (MonadIO m, IsSettingWired o) => o -> m [T.Text]
getSettingWiredS390Subchannels :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> m [Text]
getSettingWiredS390Subchannels o
obj = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe [Text]) -> IO [Text]
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getSettingWiredS390Subchannels" (IO (Maybe [Text]) -> IO [Text]) -> IO (Maybe [Text]) -> IO [Text]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe [Text])
forall a. GObject a => a -> String -> IO (Maybe [Text])
B.Properties.getObjectPropertyStringArray o
obj String
"s390-subchannels"

-- | Set the value of the “@s390-subchannels@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingWired [ #s390Subchannels 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingWiredS390Subchannels :: (MonadIO m, IsSettingWired o) => o -> [T.Text] -> m ()
setSettingWiredS390Subchannels :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> [Text] -> m ()
setSettingWiredS390Subchannels o
obj [Text]
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe [Text] -> IO ()
forall a. GObject a => a -> String -> Maybe [Text] -> IO ()
B.Properties.setObjectPropertyStringArray o
obj String
"s390-subchannels" ([Text] -> Maybe [Text]
forall a. a -> Maybe a
Just [Text]
val)

-- | Construct a t'GValueConstruct' with valid value for the “@s390-subchannels@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingWiredS390Subchannels :: (IsSettingWired o, MIO.MonadIO m) => [T.Text] -> m (GValueConstruct o)
constructSettingWiredS390Subchannels :: forall o (m :: * -> *).
(IsSettingWired o, MonadIO m) =>
[Text] -> m (GValueConstruct o)
constructSettingWiredS390Subchannels [Text]
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe [Text] -> IO (GValueConstruct o)
forall o. String -> Maybe [Text] -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyStringArray String
"s390-subchannels" ([Text] -> Maybe [Text]
forall a. a -> Maybe a
P.Just [Text]
val)

-- | Set the value of the “@s390-subchannels@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #s390Subchannels
-- @
clearSettingWiredS390Subchannels :: (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredS390Subchannels :: forall (m :: * -> *) o. (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredS390Subchannels o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe [Text] -> IO ()
forall a. GObject a => a -> String -> Maybe [Text] -> IO ()
B.Properties.setObjectPropertyStringArray o
obj String
"s390-subchannels" (Maybe [Text]
forall a. Maybe a
Nothing :: Maybe [T.Text])

#if defined(ENABLE_OVERLOADING)
data SettingWiredS390SubchannelsPropertyInfo
instance AttrInfo SettingWiredS390SubchannelsPropertyInfo where
    type AttrAllowedOps SettingWiredS390SubchannelsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SettingWiredS390SubchannelsPropertyInfo = IsSettingWired
    type AttrSetTypeConstraint SettingWiredS390SubchannelsPropertyInfo = (~) [T.Text]
    type AttrTransferTypeConstraint SettingWiredS390SubchannelsPropertyInfo = (~) [T.Text]
    type AttrTransferType SettingWiredS390SubchannelsPropertyInfo = [T.Text]
    type AttrGetType SettingWiredS390SubchannelsPropertyInfo = [T.Text]
    type AttrLabel SettingWiredS390SubchannelsPropertyInfo = "s390-subchannels"
    type AttrOrigin SettingWiredS390SubchannelsPropertyInfo = SettingWired
    attrGet = getSettingWiredS390Subchannels
    attrSet = setSettingWiredS390Subchannels
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingWiredS390Subchannels
    attrClear = clearSettingWiredS390Subchannels
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingWired.s390Subchannels"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingWired.html#g:attr:s390Subchannels"
        })
#endif

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

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

-- | Set the value of the “@speed@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingWired [ #speed 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingWiredSpeed :: (MonadIO m, IsSettingWired o) => o -> Word32 -> m ()
setSettingWiredSpeed :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> Word32 -> m ()
setSettingWiredSpeed o
obj Word32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"speed" Word32
val

-- | Construct a t'GValueConstruct' with valid value for the “@speed@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingWiredSpeed :: (IsSettingWired o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructSettingWiredSpeed :: forall o (m :: * -> *).
(IsSettingWired o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructSettingWiredSpeed Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"speed" Word32
val

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

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

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

-- | Set the value of the “@wake-on-lan@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingWired [ #wakeOnLan 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingWiredWakeOnLan :: (MonadIO m, IsSettingWired o) => o -> Word32 -> m ()
setSettingWiredWakeOnLan :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> Word32 -> m ()
setSettingWiredWakeOnLan o
obj Word32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"wake-on-lan" Word32
val

-- | Construct a t'GValueConstruct' with valid value for the “@wake-on-lan@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingWiredWakeOnLan :: (IsSettingWired o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructSettingWiredWakeOnLan :: forall o (m :: * -> *).
(IsSettingWired o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructSettingWiredWakeOnLan Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"wake-on-lan" Word32
val

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

-- VVV Prop "wake-on-lan-password"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@wake-on-lan-password@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingWired #wakeOnLanPassword
-- @
getSettingWiredWakeOnLanPassword :: (MonadIO m, IsSettingWired o) => o -> m T.Text
getSettingWiredWakeOnLanPassword :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> m Text
getSettingWiredWakeOnLanPassword o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getSettingWiredWakeOnLanPassword" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"wake-on-lan-password"

-- | Set the value of the “@wake-on-lan-password@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingWired [ #wakeOnLanPassword 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingWiredWakeOnLanPassword :: (MonadIO m, IsSettingWired o) => o -> T.Text -> m ()
setSettingWiredWakeOnLanPassword :: forall (m :: * -> *) o.
(MonadIO m, IsSettingWired o) =>
o -> Text -> m ()
setSettingWiredWakeOnLanPassword o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"wake-on-lan-password" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a t'GValueConstruct' with valid value for the “@wake-on-lan-password@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingWiredWakeOnLanPassword :: (IsSettingWired o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructSettingWiredWakeOnLanPassword :: forall o (m :: * -> *).
(IsSettingWired o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructSettingWiredWakeOnLanPassword Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"wake-on-lan-password" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@wake-on-lan-password@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #wakeOnLanPassword
-- @
clearSettingWiredWakeOnLanPassword :: (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredWakeOnLanPassword :: forall (m :: * -> *) o. (MonadIO m, IsSettingWired o) => o -> m ()
clearSettingWiredWakeOnLanPassword o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"wake-on-lan-password" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data SettingWiredWakeOnLanPasswordPropertyInfo
instance AttrInfo SettingWiredWakeOnLanPasswordPropertyInfo where
    type AttrAllowedOps SettingWiredWakeOnLanPasswordPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SettingWiredWakeOnLanPasswordPropertyInfo = IsSettingWired
    type AttrSetTypeConstraint SettingWiredWakeOnLanPasswordPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint SettingWiredWakeOnLanPasswordPropertyInfo = (~) T.Text
    type AttrTransferType SettingWiredWakeOnLanPasswordPropertyInfo = T.Text
    type AttrGetType SettingWiredWakeOnLanPasswordPropertyInfo = T.Text
    type AttrLabel SettingWiredWakeOnLanPasswordPropertyInfo = "wake-on-lan-password"
    type AttrOrigin SettingWiredWakeOnLanPasswordPropertyInfo = SettingWired
    attrGet = getSettingWiredWakeOnLanPassword
    attrSet = setSettingWiredWakeOnLanPassword
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingWiredWakeOnLanPassword
    attrClear = clearSettingWiredWakeOnLanPassword
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingWired.wakeOnLanPassword"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingWired.html#g:attr:wakeOnLanPassword"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList SettingWired
type instance O.AttributeList SettingWired = SettingWiredAttributeList
type SettingWiredAttributeList = ('[ '("acceptAllMacAddresses", SettingWiredAcceptAllMacAddressesPropertyInfo), '("autoNegotiate", SettingWiredAutoNegotiatePropertyInfo), '("clonedMacAddress", SettingWiredClonedMacAddressPropertyInfo), '("duplex", SettingWiredDuplexPropertyInfo), '("generateMacAddressMask", SettingWiredGenerateMacAddressMaskPropertyInfo), '("macAddress", SettingWiredMacAddressPropertyInfo), '("macAddressBlacklist", SettingWiredMacAddressBlacklistPropertyInfo), '("macAddressDenylist", SettingWiredMacAddressDenylistPropertyInfo), '("mtu", SettingWiredMtuPropertyInfo), '("name", NM.Setting.SettingNamePropertyInfo), '("port", SettingWiredPortPropertyInfo), '("s390Nettype", SettingWiredS390NettypePropertyInfo), '("s390Options", SettingWiredS390OptionsPropertyInfo), '("s390Subchannels", SettingWiredS390SubchannelsPropertyInfo), '("speed", SettingWiredSpeedPropertyInfo), '("wakeOnLan", SettingWiredWakeOnLanPropertyInfo), '("wakeOnLanPassword", SettingWiredWakeOnLanPasswordPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
settingWiredAcceptAllMacAddresses :: AttrLabelProxy "acceptAllMacAddresses"
settingWiredAcceptAllMacAddresses = AttrLabelProxy

settingWiredAutoNegotiate :: AttrLabelProxy "autoNegotiate"
settingWiredAutoNegotiate = AttrLabelProxy

settingWiredClonedMacAddress :: AttrLabelProxy "clonedMacAddress"
settingWiredClonedMacAddress = AttrLabelProxy

settingWiredDuplex :: AttrLabelProxy "duplex"
settingWiredDuplex = AttrLabelProxy

settingWiredGenerateMacAddressMask :: AttrLabelProxy "generateMacAddressMask"
settingWiredGenerateMacAddressMask = AttrLabelProxy

settingWiredMacAddress :: AttrLabelProxy "macAddress"
settingWiredMacAddress = AttrLabelProxy

settingWiredMacAddressBlacklist :: AttrLabelProxy "macAddressBlacklist"
settingWiredMacAddressBlacklist = AttrLabelProxy

settingWiredMacAddressDenylist :: AttrLabelProxy "macAddressDenylist"
settingWiredMacAddressDenylist = AttrLabelProxy

settingWiredMtu :: AttrLabelProxy "mtu"
settingWiredMtu = AttrLabelProxy

settingWiredPort :: AttrLabelProxy "port"
settingWiredPort = AttrLabelProxy

settingWiredS390Nettype :: AttrLabelProxy "s390Nettype"
settingWiredS390Nettype = AttrLabelProxy

settingWiredS390Options :: AttrLabelProxy "s390Options"
settingWiredS390Options = AttrLabelProxy

settingWiredS390Subchannels :: AttrLabelProxy "s390Subchannels"
settingWiredS390Subchannels = AttrLabelProxy

settingWiredSpeed :: AttrLabelProxy "speed"
settingWiredSpeed = AttrLabelProxy

settingWiredWakeOnLan :: AttrLabelProxy "wakeOnLan"
settingWiredWakeOnLan = AttrLabelProxy

settingWiredWakeOnLanPassword :: AttrLabelProxy "wakeOnLanPassword"
settingWiredWakeOnLanPassword = AttrLabelProxy

#endif

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

#endif

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

foreign import ccall "nm_setting_wired_new" nm_setting_wired_new :: 
    IO (Ptr SettingWired)

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

#if defined(ENABLE_OVERLOADING)
#endif

-- method SettingWired::add_mac_blacklist_item
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "setting"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "SettingWired" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #NMSettingWired"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mac"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the MAC address string (hex-digits-and-colons notation) to blacklist"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "nm_setting_wired_add_mac_blacklist_item" nm_setting_wired_add_mac_blacklist_item :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    CString ->                              -- mac : TBasicType TUTF8
    IO CInt

{-# DEPRECATED settingWiredAddMacBlacklistItem ["(Since version 1.48.)","Use 'GI.NM.Objects.SettingWired.settingWiredAddMacDenylistItem' instead."] #-}
-- | Adds a new MAC address to the [SettingWired:macAddressBlacklist]("GI.NM.Objects.SettingWired#g:attr:macAddressBlacklist") property.
settingWiredAddMacBlacklistItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> T.Text
    -- ^ /@mac@/: the MAC address string (hex-digits-and-colons notation) to blacklist
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the MAC address was added; 'P.False' if the MAC address
    -- is invalid or was already present
settingWiredAddMacBlacklistItem :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> Text -> m Bool
settingWiredAddMacBlacklistItem a
setting Text
mac = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CString
mac' <- Text -> IO CString
textToCString Text
mac
    CInt
result <- Ptr SettingWired -> CString -> IO CInt
nm_setting_wired_add_mac_blacklist_item Ptr SettingWired
setting' CString
mac'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
mac'
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredAddMacBlacklistItemMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredAddMacBlacklistItemMethodInfo a signature where
    overloadedMethod = settingWiredAddMacBlacklistItem

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


#endif

-- method SettingWired::add_mac_denylist_item
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "setting"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "SettingWired" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #NMSettingWired"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mac"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the MAC address string (hex-digits-and-colons notation) to denylist"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "nm_setting_wired_add_mac_denylist_item" nm_setting_wired_add_mac_denylist_item :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    CString ->                              -- mac : TBasicType TUTF8
    IO CInt

-- | Adds a new MAC address to the [SettingWired:macAddressDenylist]("GI.NM.Objects.SettingWired#g:attr:macAddressDenylist") property.
-- 
-- /Since: 1.48/
settingWiredAddMacDenylistItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> T.Text
    -- ^ /@mac@/: the MAC address string (hex-digits-and-colons notation) to denylist
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the MAC address was added; 'P.False' if the MAC address
    -- is invalid or was already present
settingWiredAddMacDenylistItem :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> Text -> m Bool
settingWiredAddMacDenylistItem a
setting Text
mac = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CString
mac' <- Text -> IO CString
textToCString Text
mac
    CInt
result <- Ptr SettingWired -> CString -> IO CInt
nm_setting_wired_add_mac_denylist_item Ptr SettingWired
setting' CString
mac'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
mac'
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredAddMacDenylistItemMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredAddMacDenylistItemMethodInfo a signature where
    overloadedMethod = settingWiredAddMacDenylistItem

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


#endif

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

foreign import ccall "nm_setting_wired_add_s390_option" nm_setting_wired_add_s390_option :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    CString ->                              -- key : TBasicType TUTF8
    CString ->                              -- value : TBasicType TUTF8
    IO CInt

-- | Add an option to the table. If the key already exists, the value gets
-- replaced.
-- 
-- Before 1.32, the function would assert that the key is valid. Since then,
-- an invalid key gets silently added but renders the profile as invalid.
settingWiredAddS390Option ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> T.Text
    -- ^ /@key@/: key name for the option
    -> T.Text
    -- ^ /@value@/: value for the option
    -> m Bool
    -- ^ __Returns:__ since 1.32 this always returns 'P.True'.
settingWiredAddS390Option :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> Text -> Text -> m Bool
settingWiredAddS390Option a
setting Text
key Text
value = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CString
key' <- Text -> IO CString
textToCString Text
key
    CString
value' <- Text -> IO CString
textToCString Text
value
    CInt
result <- Ptr SettingWired -> CString -> CString -> IO CInt
nm_setting_wired_add_s390_option Ptr SettingWired
setting' CString
key' CString
value'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
value'
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredAddS390OptionMethodInfo
instance (signature ~ (T.Text -> T.Text -> m Bool), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredAddS390OptionMethodInfo a signature where
    overloadedMethod = settingWiredAddS390Option

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


#endif

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

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

{-# DEPRECATED settingWiredClearMacBlacklistItems ["(Since version 1.48.)","Use 'GI.NM.Objects.SettingWired.settingWiredClearMacDenylistItems' instead."] #-}
-- | Removes all blacklisted MAC addresses.
settingWiredClearMacBlacklistItems ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> m ()
settingWiredClearMacBlacklistItems :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> m ()
settingWiredClearMacBlacklistItems a
setting = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    Ptr SettingWired -> IO ()
nm_setting_wired_clear_mac_blacklist_items Ptr SettingWired
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SettingWiredClearMacBlacklistItemsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredClearMacBlacklistItemsMethodInfo a signature where
    overloadedMethod = settingWiredClearMacBlacklistItems

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


#endif

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

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

-- | Removes all denylisted MAC addresses.
-- 
-- /Since: 1.48/
settingWiredClearMacDenylistItems ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> m ()
settingWiredClearMacDenylistItems :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> m ()
settingWiredClearMacDenylistItems a
setting = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    Ptr SettingWired -> IO ()
nm_setting_wired_clear_mac_denylist_items Ptr SettingWired
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SettingWiredClearMacDenylistItemsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredClearMacDenylistItemsMethodInfo a signature where
    overloadedMethod = settingWiredClearMacDenylistItems

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


#endif

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

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

-- | /No description available in the introspection data./
-- 
-- /Since: 1.32/
settingWiredGetAcceptAllMacAddresses ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> m NM.Enums.Ternary
    -- ^ __Returns:__ the [SettingWired:acceptAllMacAddresses]("GI.NM.Objects.SettingWired#g:attr:acceptAllMacAddresses") property of the setting
settingWiredGetAcceptAllMacAddresses :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> m Ternary
settingWiredGetAcceptAllMacAddresses a
setting = IO Ternary -> m Ternary
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Ternary -> m Ternary) -> IO Ternary -> m Ternary
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CInt
result <- Ptr SettingWired -> IO CInt
nm_setting_wired_get_accept_all_mac_addresses Ptr SettingWired
setting'
    let result' :: Ternary
result' = (Int -> Ternary
forall a. Enum a => Int -> a
toEnum (Int -> Ternary) -> (CInt -> Int) -> CInt -> Ternary
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Ternary -> IO Ternary
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ternary
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetAcceptAllMacAddressesMethodInfo
instance (signature ~ (m NM.Enums.Ternary), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetAcceptAllMacAddressesMethodInfo a signature where
    overloadedMethod = settingWiredGetAcceptAllMacAddresses

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


#endif

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

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

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

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetAutoNegotiateMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetAutoNegotiateMethodInfo a signature where
    overloadedMethod = settingWiredGetAutoNegotiate

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


#endif

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

foreign import ccall "nm_setting_wired_get_cloned_mac_address" nm_setting_wired_get_cloned_mac_address :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    IO CString

-- | /No description available in the introspection data./
settingWiredGetClonedMacAddress ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> m T.Text
    -- ^ __Returns:__ the [SettingWired:clonedMacAddress]("GI.NM.Objects.SettingWired#g:attr:clonedMacAddress") property of the setting
settingWiredGetClonedMacAddress :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> m Text
settingWiredGetClonedMacAddress a
setting = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CString
result <- Ptr SettingWired -> IO CString
nm_setting_wired_get_cloned_mac_address Ptr SettingWired
setting'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"settingWiredGetClonedMacAddress" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetClonedMacAddressMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetClonedMacAddressMethodInfo a signature where
    overloadedMethod = settingWiredGetClonedMacAddress

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


#endif

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

foreign import ccall "nm_setting_wired_get_duplex" nm_setting_wired_get_duplex :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    IO CString

-- | /No description available in the introspection data./
settingWiredGetDuplex ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> m T.Text
    -- ^ __Returns:__ the [SettingWired:duplex]("GI.NM.Objects.SettingWired#g:attr:duplex") property of the setting
settingWiredGetDuplex :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> m Text
settingWiredGetDuplex a
setting = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CString
result <- Ptr SettingWired -> IO CString
nm_setting_wired_get_duplex Ptr SettingWired
setting'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"settingWiredGetDuplex" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetDuplexMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetDuplexMethodInfo a signature where
    overloadedMethod = settingWiredGetDuplex

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


#endif

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

foreign import ccall "nm_setting_wired_get_generate_mac_address_mask" nm_setting_wired_get_generate_mac_address_mask :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    IO CString

-- | /No description available in the introspection data./
-- 
-- /Since: 1.4/
settingWiredGetGenerateMacAddressMask ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> m T.Text
    -- ^ __Returns:__ the [SettingWired:generateMacAddressMask]("GI.NM.Objects.SettingWired#g:attr:generateMacAddressMask") property of the setting
settingWiredGetGenerateMacAddressMask :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> m Text
settingWiredGetGenerateMacAddressMask a
setting = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CString
result <- Ptr SettingWired -> IO CString
nm_setting_wired_get_generate_mac_address_mask Ptr SettingWired
setting'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"settingWiredGetGenerateMacAddressMask" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetGenerateMacAddressMaskMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetGenerateMacAddressMaskMethodInfo a signature where
    overloadedMethod = settingWiredGetGenerateMacAddressMask

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


#endif

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

foreign import ccall "nm_setting_wired_get_mac_address" nm_setting_wired_get_mac_address :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    IO CString

-- | /No description available in the introspection data./
settingWiredGetMacAddress ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> m T.Text
    -- ^ __Returns:__ the [SettingWired:macAddress]("GI.NM.Objects.SettingWired#g:attr:macAddress") property of the setting
settingWiredGetMacAddress :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> m Text
settingWiredGetMacAddress a
setting = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CString
result <- Ptr SettingWired -> IO CString
nm_setting_wired_get_mac_address Ptr SettingWired
setting'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"settingWiredGetMacAddress" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetMacAddressMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetMacAddressMethodInfo a signature where
    overloadedMethod = settingWiredGetMacAddress

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


#endif

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

foreign import ccall "nm_setting_wired_get_mac_address_blacklist" nm_setting_wired_get_mac_address_blacklist :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    IO (Ptr CString)

{-# DEPRECATED settingWiredGetMacAddressBlacklist ["(Since version 1.48.)","Use 'GI.NM.Objects.SettingWired.settingWiredGetMacAddressDenylist' instead."] #-}
-- | /No description available in the introspection data./
settingWiredGetMacAddressBlacklist ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> m [T.Text]
    -- ^ __Returns:__ the [SettingWired:macAddressBlacklist]("GI.NM.Objects.SettingWired#g:attr:macAddressBlacklist") property of the setting
settingWiredGetMacAddressBlacklist :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> m [Text]
settingWiredGetMacAddressBlacklist a
setting = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    Ptr CString
result <- Ptr SettingWired -> IO (Ptr CString)
nm_setting_wired_get_mac_address_blacklist Ptr SettingWired
setting'
    Text -> Ptr CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"settingWiredGetMacAddressBlacklist" Ptr CString
result
    [Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    [Text] -> IO [Text]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetMacAddressBlacklistMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetMacAddressBlacklistMethodInfo a signature where
    overloadedMethod = settingWiredGetMacAddressBlacklist

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


#endif

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

foreign import ccall "nm_setting_wired_get_mac_address_denylist" nm_setting_wired_get_mac_address_denylist :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    IO (Ptr CString)

-- | /No description available in the introspection data./
-- 
-- /Since: 1.48/
settingWiredGetMacAddressDenylist ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> m [T.Text]
    -- ^ __Returns:__ the [SettingWired:macAddressDenylist]("GI.NM.Objects.SettingWired#g:attr:macAddressDenylist") property of the setting
settingWiredGetMacAddressDenylist :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> m [Text]
settingWiredGetMacAddressDenylist a
setting = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    Ptr CString
result <- Ptr SettingWired -> IO (Ptr CString)
nm_setting_wired_get_mac_address_denylist Ptr SettingWired
setting'
    Text -> Ptr CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"settingWiredGetMacAddressDenylist" Ptr CString
result
    [Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    [Text] -> IO [Text]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetMacAddressDenylistMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetMacAddressDenylistMethodInfo a signature where
    overloadedMethod = settingWiredGetMacAddressDenylist

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


#endif

-- method SettingWired::get_mac_blacklist_item
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "setting"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "SettingWired" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #NMSettingWired"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "idx"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the zero-based index of the MAC address entry"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "nm_setting_wired_get_mac_blacklist_item" nm_setting_wired_get_mac_blacklist_item :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    Word32 ->                               -- idx : TBasicType TUInt32
    IO CString

{-# DEPRECATED settingWiredGetMacBlacklistItem ["(Since version 1.48.)","Use 'GI.NM.Objects.SettingWired.settingWiredGetMacDenylistItem' instead."] #-}
-- | Since 1.48, access at index \"len\" is allowed and returns NULL.
settingWiredGetMacBlacklistItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> Word32
    -- ^ /@idx@/: the zero-based index of the MAC address entry
    -> m T.Text
    -- ^ __Returns:__ the blacklisted MAC address string (hex-digits-and-colons notation)
    -- at index /@idx@/
settingWiredGetMacBlacklistItem :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> Word32 -> m Text
settingWiredGetMacBlacklistItem a
setting Word32
idx = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CString
result <- Ptr SettingWired -> Word32 -> IO CString
nm_setting_wired_get_mac_blacklist_item Ptr SettingWired
setting' Word32
idx
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"settingWiredGetMacBlacklistItem" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetMacBlacklistItemMethodInfo
instance (signature ~ (Word32 -> m T.Text), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetMacBlacklistItemMethodInfo a signature where
    overloadedMethod = settingWiredGetMacBlacklistItem

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


#endif

-- method SettingWired::get_mac_denylist_item
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "setting"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "SettingWired" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #NMSettingWired"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "idx"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the zero-based index of the MAC address entry"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "nm_setting_wired_get_mac_denylist_item" nm_setting_wired_get_mac_denylist_item :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    Word32 ->                               -- idx : TBasicType TUInt32
    IO CString

-- | /No description available in the introspection data./
-- 
-- /Since: 1.48/
settingWiredGetMacDenylistItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> Word32
    -- ^ /@idx@/: the zero-based index of the MAC address entry
    -> m T.Text
    -- ^ __Returns:__ the denylisted MAC address string (hex-digits-and-colons notation)
    -- at index /@idx@/
settingWiredGetMacDenylistItem :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> Word32 -> m Text
settingWiredGetMacDenylistItem a
setting Word32
idx = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CString
result <- Ptr SettingWired -> Word32 -> IO CString
nm_setting_wired_get_mac_denylist_item Ptr SettingWired
setting' Word32
idx
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"settingWiredGetMacDenylistItem" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetMacDenylistItemMethodInfo
instance (signature ~ (Word32 -> m T.Text), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetMacDenylistItemMethodInfo a signature where
    overloadedMethod = settingWiredGetMacDenylistItem

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


#endif

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

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

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

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetMtuMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetMtuMethodInfo a signature where
    overloadedMethod = settingWiredGetMtu

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


#endif

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

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

{-# DEPRECATED settingWiredGetNumMacBlacklistItems ["(Since version 1.48.)","Use 'GI.NM.Objects.SettingWired.settingWiredGetNumMacDenylistItems' instead."] #-}
-- | /No description available in the introspection data./
settingWiredGetNumMacBlacklistItems ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> m Word32
    -- ^ __Returns:__ the number of blacklisted MAC addresses
settingWiredGetNumMacBlacklistItems :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> m Word32
settingWiredGetNumMacBlacklistItems a
setting = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    Word32
result <- Ptr SettingWired -> IO Word32
nm_setting_wired_get_num_mac_blacklist_items Ptr SettingWired
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetNumMacBlacklistItemsMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetNumMacBlacklistItemsMethodInfo a signature where
    overloadedMethod = settingWiredGetNumMacBlacklistItems

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


#endif

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

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

-- | /No description available in the introspection data./
-- 
-- /Since: 1.48/
settingWiredGetNumMacDenylistItems ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> m Word32
    -- ^ __Returns:__ the number of denylisted MAC addresses
settingWiredGetNumMacDenylistItems :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> m Word32
settingWiredGetNumMacDenylistItems a
setting = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    Word32
result <- Ptr SettingWired -> IO Word32
nm_setting_wired_get_num_mac_denylist_items Ptr SettingWired
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetNumMacDenylistItemsMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetNumMacDenylistItemsMethodInfo a signature where
    overloadedMethod = settingWiredGetNumMacDenylistItems

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


#endif

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

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

-- | Returns the number of s390-specific options that should be set for this
-- device when it is activated.  This can be used to retrieve each s390
-- option individually using 'GI.NM.Objects.SettingWired.settingWiredGetS390Option'.
settingWiredGetNumS390Options ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> m Word32
    -- ^ __Returns:__ the number of s390-specific device options
settingWiredGetNumS390Options :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> m Word32
settingWiredGetNumS390Options a
setting = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    Word32
result <- Ptr SettingWired -> IO Word32
nm_setting_wired_get_num_s390_options Ptr SettingWired
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetNumS390OptionsMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetNumS390OptionsMethodInfo a signature where
    overloadedMethod = settingWiredGetNumS390Options

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


#endif

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

foreign import ccall "nm_setting_wired_get_port" nm_setting_wired_get_port :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    IO CString

-- | /No description available in the introspection data./
settingWiredGetPort ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> m T.Text
    -- ^ __Returns:__ the [SettingWired:port]("GI.NM.Objects.SettingWired#g:attr:port") property of the setting
settingWiredGetPort :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> m Text
settingWiredGetPort a
setting = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CString
result <- Ptr SettingWired -> IO CString
nm_setting_wired_get_port Ptr SettingWired
setting'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"settingWiredGetPort" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetPortMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetPortMethodInfo a signature where
    overloadedMethod = settingWiredGetPort

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


#endif

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

foreign import ccall "nm_setting_wired_get_s390_nettype" nm_setting_wired_get_s390_nettype :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    IO CString

-- | Returns the s390 device type this connection should apply to.  Will be one
-- of \'qeth\', \'lcs\', or \'ctc\'.
settingWiredGetS390Nettype ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> m T.Text
    -- ^ __Returns:__ the s390 device type
settingWiredGetS390Nettype :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> m Text
settingWiredGetS390Nettype a
setting = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CString
result <- Ptr SettingWired -> IO CString
nm_setting_wired_get_s390_nettype Ptr SettingWired
setting'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"settingWiredGetS390Nettype" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetS390NettypeMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetS390NettypeMethodInfo a signature where
    overloadedMethod = settingWiredGetS390Nettype

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


#endif

-- method SettingWired::get_s390_option
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "setting"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "SettingWired" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #NMSettingWired"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "idx"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "index of the desired option, from 0 to\nnm_setting_wired_get_num_s390_options() - 1"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_key"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "on return, the key\n  name of the s390 specific option; this value is owned by the setting and\n  should not be modified"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_value"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "on return, the value\n  of the key of the s390 specific option; this value is owned by the setting\n  and should not be modified"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "nm_setting_wired_get_s390_option" nm_setting_wired_get_s390_option :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    Word32 ->                               -- idx : TBasicType TUInt32
    Ptr CString ->                          -- out_key : TBasicType TUTF8
    Ptr CString ->                          -- out_value : TBasicType TUTF8
    IO CInt

-- | Given an index, return the value of the s390 option at that index.  indexes
-- are *not* guaranteed to be static across modifications to options done by
-- 'GI.NM.Objects.SettingWired.settingWiredAddS390Option' and 'GI.NM.Objects.SettingWired.settingWiredRemoveS390Option',
-- and should not be used to refer to options except for short periods of time
-- such as during option iteration.
settingWiredGetS390Option ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> Word32
    -- ^ /@idx@/: index of the desired option, from 0 to
    -- 'GI.NM.Objects.SettingWired.settingWiredGetNumS390Options' - 1
    -> m ((Bool, Maybe T.Text, Maybe T.Text))
    -- ^ __Returns:__ 'P.True' on success if the index was valid and an option was found,
    -- 'P.False' if the index was invalid (ie, greater than the number of options
    -- currently held by the setting)
settingWiredGetS390Option :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> Word32 -> m (Bool, Maybe Text, Maybe Text)
settingWiredGetS390Option a
setting Word32
idx = IO (Bool, Maybe Text, Maybe Text)
-> m (Bool, Maybe Text, Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Maybe Text, Maybe Text)
 -> m (Bool, Maybe Text, Maybe Text))
-> IO (Bool, Maybe Text, Maybe Text)
-> m (Bool, Maybe Text, Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    Ptr CString
outKey <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr CString
outValue <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    CInt
result <- Ptr SettingWired -> Word32 -> Ptr CString -> Ptr CString -> IO CInt
nm_setting_wired_get_s390_option Ptr SettingWired
setting' Word32
idx Ptr CString
outKey Ptr CString
outValue
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    CString
outKey' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outKey
    Maybe Text
maybeOutKey' <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
outKey' ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
outKey'' -> do
        Text
outKey''' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
outKey''
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
outKey'''
    CString
outValue' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outValue
    Maybe Text
maybeOutValue' <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
outValue' ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
outValue'' -> do
        Text
outValue''' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
outValue''
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
outValue'''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
outKey
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
outValue
    (Bool, Maybe Text, Maybe Text) -> IO (Bool, Maybe Text, Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Maybe Text
maybeOutKey', Maybe Text
maybeOutValue')

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetS390OptionMethodInfo
instance (signature ~ (Word32 -> m ((Bool, Maybe T.Text, Maybe T.Text))), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetS390OptionMethodInfo a signature where
    overloadedMethod = settingWiredGetS390Option

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


#endif

-- method SettingWired::get_s390_option_by_key
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "setting"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "SettingWired" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #NMSettingWired"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the key for which to retrieve the value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "nm_setting_wired_get_s390_option_by_key" nm_setting_wired_get_s390_option_by_key :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    CString ->                              -- key : TBasicType TUTF8
    IO CString

-- | Returns the value associated with the s390-specific option specified by
-- /@key@/, if it exists.
settingWiredGetS390OptionByKey ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> T.Text
    -- ^ /@key@/: the key for which to retrieve the value
    -> m T.Text
    -- ^ __Returns:__ the value, or 'P.Nothing' if the key\/value pair was never added to the
    -- setting; the value is owned by the setting and must not be modified
settingWiredGetS390OptionByKey :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> Text -> m Text
settingWiredGetS390OptionByKey a
setting Text
key = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CString
key' <- Text -> IO CString
textToCString Text
key
    CString
result <- Ptr SettingWired -> CString -> IO CString
nm_setting_wired_get_s390_option_by_key Ptr SettingWired
setting' CString
key'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"settingWiredGetS390OptionByKey" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

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

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


#endif

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

foreign import ccall "nm_setting_wired_get_s390_subchannels" nm_setting_wired_get_s390_subchannels :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    IO (Ptr CString)

-- | Return the list of s390 subchannels that identify the device that this
-- connection is applicable to.  The connection should only be used in
-- conjunction with that device.
settingWiredGetS390Subchannels ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> m [T.Text]
    -- ^ __Returns:__ array of strings, each specifying
    --   one subchannel the s390 device uses to communicate to the host.
settingWiredGetS390Subchannels :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> m [Text]
settingWiredGetS390Subchannels a
setting = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    Ptr CString
result <- Ptr SettingWired -> IO (Ptr CString)
nm_setting_wired_get_s390_subchannels Ptr SettingWired
setting'
    Text -> Ptr CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"settingWiredGetS390Subchannels" Ptr CString
result
    [Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    [Text] -> IO [Text]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetS390SubchannelsMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetS390SubchannelsMethodInfo a signature where
    overloadedMethod = settingWiredGetS390Subchannels

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


#endif

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

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

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

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetSpeedMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetSpeedMethodInfo a signature where
    overloadedMethod = settingWiredGetSpeed

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


#endif

-- method SettingWired::get_valid_s390_options
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "setting"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "SettingWired" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the #NMSettingWired. This argument is unused\n  and you may pass %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TCArray True (-1) (-1) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "nm_setting_wired_get_valid_s390_options" nm_setting_wired_get_valid_s390_options :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    IO (Ptr CString)

-- | Returns a list of valid s390 options.
-- 
-- The /@setting@/ argument is unused and 'P.Nothing' may be passed instead.
settingWiredGetValidS390Options ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    Maybe (a)
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'. This argument is unused
    --   and you may pass 'P.Nothing'.
    -> m [T.Text]
    -- ^ __Returns:__ a 'P.Nothing'-terminated array of strings of valid s390 options.
settingWiredGetValidS390Options :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
Maybe a -> m [Text]
settingWiredGetValidS390Options Maybe a
setting = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
maybeSetting <- case Maybe a
setting of
        Maybe a
Nothing -> Ptr SettingWired -> IO (Ptr SettingWired)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr SettingWired
forall a. Ptr a
FP.nullPtr
        Just a
jSetting -> do
            Ptr SettingWired
jSetting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSetting
            Ptr SettingWired -> IO (Ptr SettingWired)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr SettingWired
jSetting'
    Ptr CString
result <- Ptr SettingWired -> IO (Ptr CString)
nm_setting_wired_get_valid_s390_options Ptr SettingWired
maybeSetting
    Text -> Ptr CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"settingWiredGetValidS390Options" Ptr CString
result
    [Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
    Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
setting a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    [Text] -> IO [Text]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetValidS390OptionsMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetValidS390OptionsMethodInfo a signature where
    overloadedMethod i = settingWiredGetValidS390Options (Just i)

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


#endif

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

foreign import ccall "nm_setting_wired_get_wake_on_lan" nm_setting_wired_get_wake_on_lan :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    IO CUInt

-- | Returns the Wake-on-LAN options enabled for the connection
-- 
-- /Since: 1.2/
settingWiredGetWakeOnLan ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> m [NM.Flags.SettingWiredWakeOnLan]
    -- ^ __Returns:__ the Wake-on-LAN options
settingWiredGetWakeOnLan :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> m [SettingWiredWakeOnLan]
settingWiredGetWakeOnLan a
setting = IO [SettingWiredWakeOnLan] -> m [SettingWiredWakeOnLan]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [SettingWiredWakeOnLan] -> m [SettingWiredWakeOnLan])
-> IO [SettingWiredWakeOnLan] -> m [SettingWiredWakeOnLan]
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CUInt
result <- Ptr SettingWired -> IO CUInt
nm_setting_wired_get_wake_on_lan Ptr SettingWired
setting'
    let result' :: [SettingWiredWakeOnLan]
result' = CUInt -> [SettingWiredWakeOnLan]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    [SettingWiredWakeOnLan] -> IO [SettingWiredWakeOnLan]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [SettingWiredWakeOnLan]
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetWakeOnLanMethodInfo
instance (signature ~ (m [NM.Flags.SettingWiredWakeOnLan]), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetWakeOnLanMethodInfo a signature where
    overloadedMethod = settingWiredGetWakeOnLan

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


#endif

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

foreign import ccall "nm_setting_wired_get_wake_on_lan_password" nm_setting_wired_get_wake_on_lan_password :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    IO CString

-- | Returns the Wake-on-LAN password. This only applies to
-- 'GI.NM.Flags.SettingWiredWakeOnLanMagic'.
-- 
-- /Since: 1.2/
settingWiredGetWakeOnLanPassword ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> m T.Text
    -- ^ __Returns:__ the Wake-on-LAN setting password, or 'P.Nothing' if there is no password.
settingWiredGetWakeOnLanPassword :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> m Text
settingWiredGetWakeOnLanPassword a
setting = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CString
result <- Ptr SettingWired -> IO CString
nm_setting_wired_get_wake_on_lan_password Ptr SettingWired
setting'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"settingWiredGetWakeOnLanPassword" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredGetWakeOnLanPasswordMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredGetWakeOnLanPasswordMethodInfo a signature where
    overloadedMethod = settingWiredGetWakeOnLanPassword

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


#endif

-- method SettingWired::remove_mac_blacklist_item
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "setting"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "SettingWired" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #NMSettingWired"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "idx"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "index number of the MAC address"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "nm_setting_wired_remove_mac_blacklist_item" nm_setting_wired_remove_mac_blacklist_item :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    Word32 ->                               -- idx : TBasicType TUInt32
    IO ()

{-# DEPRECATED settingWiredRemoveMacBlacklistItem ["(Since version 1.48.)","Use 'GI.NM.Objects.SettingWired.settingWiredRemoveMacDenylistItem' instead."] #-}
-- | Removes the MAC address at index /@idx@/ from the blacklist.
settingWiredRemoveMacBlacklistItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> Word32
    -- ^ /@idx@/: index number of the MAC address
    -> m ()
settingWiredRemoveMacBlacklistItem :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> Word32 -> m ()
settingWiredRemoveMacBlacklistItem a
setting Word32
idx = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    Ptr SettingWired -> Word32 -> IO ()
nm_setting_wired_remove_mac_blacklist_item Ptr SettingWired
setting' Word32
idx
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SettingWiredRemoveMacBlacklistItemMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredRemoveMacBlacklistItemMethodInfo a signature where
    overloadedMethod = settingWiredRemoveMacBlacklistItem

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


#endif

-- method SettingWired::remove_mac_blacklist_item_by_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "setting"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "SettingWired" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #NMSettingWired"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mac"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the MAC address string (hex-digits-and-colons notation) to remove from\nthe blacklist"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "nm_setting_wired_remove_mac_blacklist_item_by_value" nm_setting_wired_remove_mac_blacklist_item_by_value :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    CString ->                              -- mac : TBasicType TUTF8
    IO CInt

{-# DEPRECATED settingWiredRemoveMacBlacklistItemByValue ["(Since version 1.48.)","Use 'GI.NM.Objects.SettingWired.settingWiredRemoveMacDenylistItemByValue' instead."] #-}
-- | Removes the MAC address /@mac@/ from the blacklist.
settingWiredRemoveMacBlacklistItemByValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> T.Text
    -- ^ /@mac@/: the MAC address string (hex-digits-and-colons notation) to remove from
    -- the blacklist
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the MAC address was found and removed; 'P.False' if it was not.
settingWiredRemoveMacBlacklistItemByValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> Text -> m Bool
settingWiredRemoveMacBlacklistItemByValue a
setting Text
mac = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CString
mac' <- Text -> IO CString
textToCString Text
mac
    CInt
result <- Ptr SettingWired -> CString -> IO CInt
nm_setting_wired_remove_mac_blacklist_item_by_value Ptr SettingWired
setting' CString
mac'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
mac'
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredRemoveMacBlacklistItemByValueMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredRemoveMacBlacklistItemByValueMethodInfo a signature where
    overloadedMethod = settingWiredRemoveMacBlacklistItemByValue

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


#endif

-- method SettingWired::remove_mac_denylist_item
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "setting"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "SettingWired" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #NMSettingWired"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "idx"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "index number of the MAC address"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "nm_setting_wired_remove_mac_denylist_item" nm_setting_wired_remove_mac_denylist_item :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    Word32 ->                               -- idx : TBasicType TUInt32
    IO ()

-- | Removes the MAC address at index /@idx@/ from the denylist.
-- 
-- /Since: 1.48/
settingWiredRemoveMacDenylistItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> Word32
    -- ^ /@idx@/: index number of the MAC address
    -> m ()
settingWiredRemoveMacDenylistItem :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> Word32 -> m ()
settingWiredRemoveMacDenylistItem a
setting Word32
idx = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    Ptr SettingWired -> Word32 -> IO ()
nm_setting_wired_remove_mac_denylist_item Ptr SettingWired
setting' Word32
idx
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SettingWiredRemoveMacDenylistItemMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredRemoveMacDenylistItemMethodInfo a signature where
    overloadedMethod = settingWiredRemoveMacDenylistItem

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


#endif

-- method SettingWired::remove_mac_denylist_item_by_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "setting"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "SettingWired" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #NMSettingWired"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mac"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the MAC address string (hex-digits-and-colons notation) to remove from\nthe denylist"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "nm_setting_wired_remove_mac_denylist_item_by_value" nm_setting_wired_remove_mac_denylist_item_by_value :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    CString ->                              -- mac : TBasicType TUTF8
    IO CInt

-- | Removes the MAC address /@mac@/ from the denylist.
-- 
-- /Since: 1.48/
settingWiredRemoveMacDenylistItemByValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> T.Text
    -- ^ /@mac@/: the MAC address string (hex-digits-and-colons notation) to remove from
    -- the denylist
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the MAC address was found and removed; 'P.False' if it was not.
settingWiredRemoveMacDenylistItemByValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> Text -> m Bool
settingWiredRemoveMacDenylistItemByValue a
setting Text
mac = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CString
mac' <- Text -> IO CString
textToCString Text
mac
    CInt
result <- Ptr SettingWired -> CString -> IO CInt
nm_setting_wired_remove_mac_denylist_item_by_value Ptr SettingWired
setting' CString
mac'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
mac'
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredRemoveMacDenylistItemByValueMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredRemoveMacDenylistItemByValueMethodInfo a signature where
    overloadedMethod = settingWiredRemoveMacDenylistItemByValue

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


#endif

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

foreign import ccall "nm_setting_wired_remove_s390_option" nm_setting_wired_remove_s390_option :: 
    Ptr SettingWired ->                     -- setting : TInterface (Name {namespace = "NM", name = "SettingWired"})
    CString ->                              -- key : TBasicType TUTF8
    IO CInt

-- | Remove the s390-specific option referenced by /@key@/ from the internal option
-- list.
settingWiredRemoveS390Option ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingWired a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingWired.SettingWired'
    -> T.Text
    -- ^ /@key@/: key name for the option to remove
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the option was found and removed from the internal option
    -- list, 'P.False' if it was not.
settingWiredRemoveS390Option :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingWired a) =>
a -> Text -> m Bool
settingWiredRemoveS390Option a
setting Text
key = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingWired
setting' <- a -> IO (Ptr SettingWired)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CString
key' <- Text -> IO CString
textToCString Text
key
    CInt
result <- Ptr SettingWired -> CString -> IO CInt
nm_setting_wired_remove_s390_option Ptr SettingWired
setting' CString
key'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SettingWiredRemoveS390OptionMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsSettingWired a) => O.OverloadedMethod SettingWiredRemoveS390OptionMethodInfo a signature where
    overloadedMethod = settingWiredRemoveS390Option

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


#endif