///
///
///
///
/**
* Type Definitions for Gjs (https://gjs.guide/)
*
* These type definitions are automatically generated, do not edit them by hand.
* If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
*
* The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
*/
declare module 'gi://NM?version=1.0' {
// Module dependencies
import type Gio from 'gi://Gio?version=2.0';
import type GObject from 'gi://GObject?version=2.0';
import type GLib from 'gi://GLib?version=2.0';
import type GModule from 'gi://GModule?version=2.0';
export namespace NM {
/**
* NM-1.0
*/
/**
* Indicates the 802.11 mode an access point or device is currently in.
*/
/**
* Indicates the 802.11 mode an access point or device is currently in.
*/
export namespace __80211Mode {
export const $gtype: GObject.GType<__80211Mode>;
}
enum __80211Mode {
/**
* the device or access point mode is unknown
*/
UNKNOWN,
/**
* for both devices and access point objects, indicates
* the object is part of an Ad-Hoc 802.11 network without a central
* coordinating access point.
*/
ADHOC,
/**
* the device or access point is in infrastructure mode.
* For devices, this indicates the device is an 802.11 client/station. For
* access point objects, this indicates the object is an access point that
* provides connectivity to clients.
*/
INFRA,
/**
* the device is an access point/hotspot. Not valid for
* access point objects; used only for hotspot mode on the local machine.
*/
AP,
/**
* the device is a 802.11s mesh point. Since: 1.20.
*/
MESH,
}
/**
* #NMActiveConnectionState values indicate the state of a connection to a
* specific network while it is starting, connected, or disconnecting from that
* network.
*/
/**
* #NMActiveConnectionState values indicate the state of a connection to a
* specific network while it is starting, connected, or disconnecting from that
* network.
*/
export namespace ActiveConnectionState {
export const $gtype: GObject.GType;
}
enum ActiveConnectionState {
/**
* the state of the connection is unknown
*/
UNKNOWN,
/**
* a network connection is being prepared
*/
ACTIVATING,
/**
* there is a connection to the network
*/
ACTIVATED,
/**
* the network connection is being
* torn down and cleaned up
*/
DEACTIVATING,
/**
* the network connection is disconnected
* and will be removed
*/
DEACTIVATED,
}
/**
* Active connection state reasons.
*/
/**
* Active connection state reasons.
*/
export namespace ActiveConnectionStateReason {
export const $gtype: GObject.GType;
}
enum ActiveConnectionStateReason {
/**
* The reason for the active connection
* state change is unknown.
*/
UNKNOWN,
/**
* No reason was given for the active
* connection state change.
*/
NONE,
/**
* The active connection changed
* state because the user disconnected it.
*/
USER_DISCONNECTED,
/**
* The active connection
* changed state because the device it was using was disconnected.
*/
DEVICE_DISCONNECTED,
/**
* The service providing the
* VPN connection was stopped.
*/
SERVICE_STOPPED,
/**
* The IP config of the active
* connection was invalid.
*/
IP_CONFIG_INVALID,
/**
* The connection attempt to
* the VPN service timed out.
*/
CONNECT_TIMEOUT,
/**
* A timeout occurred
* while starting the service providing the VPN connection.
*/
SERVICE_START_TIMEOUT,
/**
* Starting the service
* providing the VPN connection failed.
*/
SERVICE_START_FAILED,
/**
* Necessary secrets for the
* connection were not provided.
*/
NO_SECRETS,
/**
* Authentication to the
* server failed.
*/
LOGIN_FAILED,
/**
* The connection was
* deleted from settings.
*/
CONNECTION_REMOVED,
/**
* Master connection of this
* connection failed to activate.
*/
DEPENDENCY_FAILED,
/**
* Could not create the
* software device link.
*/
DEVICE_REALIZE_FAILED,
/**
* The device this connection
* depended on disappeared.
*/
DEVICE_REMOVED,
}
/**
* Errors returned from the secret-agent manager.
*
* These errors may be returned from operations that could cause secrets to be
* requested (such as nm_client_activate_connection()), and correspond to D-Bus
* errors in the "org.freedesktop.NetworkManager.AgentManager" namespace.
*/
class AgentManagerError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
/**
* unknown or unspecified error
*/
static FAILED: number;
/**
* The caller does not have permission
* to register a secret agent, or is trying to register the same secret agent
* twice.
*/
static PERMISSIONDENIED: number;
/**
* The identifier is not a valid
* secret agent identifier.
*/
static INVALIDIDENTIFIER: number;
/**
* The caller tried to unregister an agent
* that was not registered.
*/
static NOTREGISTERED: number;
/**
* No secret agent returned secrets for this
* request
*/
static NOSECRETS: number;
/**
* The user canceled the secrets request.
*/
static USERCANCELED: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
// Static methods
static quark(): GLib.Quark;
}
/**
* #NMCapability names the numbers in the Capabilities property.
* Capabilities are positive numbers. They are part of stable API
* and a certain capability number is guaranteed not to change.
*
* The range 0x7000 - 0x7FFF of capabilities is guaranteed not to be
* used by upstream NetworkManager. It could thus be used for downstream
* extensions.
*/
/**
* #NMCapability names the numbers in the Capabilities property.
* Capabilities are positive numbers. They are part of stable API
* and a certain capability number is guaranteed not to change.
*
* The range 0x7000 - 0x7FFF of capabilities is guaranteed not to be
* used by upstream NetworkManager. It could thus be used for downstream
* extensions.
*/
export namespace Capability {
export const $gtype: GObject.GType;
}
enum Capability {
/**
* Teams can be managed. This means the team device plugin
* is loaded.
*/
TEAM,
/**
* OpenVSwitch can be managed. This means the OVS device plugin
* is loaded. Since: 1.24.
*/
OVS,
}
/**
* Describes errors that may result from operations involving a #NMClient.
*
* D-Bus operations may also return errors from other domains, including
* #NMManagerError, #NMSettingsError, #NMAgentManagerError, and #NMConnectionError.
*/
class ClientError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
/**
* unknown or unclassified error
*/
static FAILED: number;
/**
* an operation that requires NetworkManager
* failed because NetworkManager is not running
*/
static MANAGER_NOT_RUNNING: number;
/**
* NetworkManager claimed that an
* operation succeeded, but the object that was allegedly created (eg,
* #NMRemoteConnection, #NMActiveConnection) was apparently destroyed before
* #NMClient could create a representation of it.
*/
static OBJECT_CREATION_FAILED: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
// Static methods
/**
* Registers an error quark for #NMClient if necessary.
*/
static quark(): GLib.Quark;
}
/**
* #NMClientPermission values indicate various permissions that NetworkManager
* clients can obtain to perform certain tasks on behalf of the current user.
*/
/**
* #NMClientPermission values indicate various permissions that NetworkManager
* clients can obtain to perform certain tasks on behalf of the current user.
*/
export namespace ClientPermission {
export const $gtype: GObject.GType;
}
enum ClientPermission {
/**
* unknown or no permission
*/
NONE,
/**
* controls whether networking
* can be globally enabled or disabled
*/
ENABLE_DISABLE_NETWORK,
/**
* controls whether Wi-Fi can be
* globally enabled or disabled
*/
ENABLE_DISABLE_WIFI,
/**
* controls whether WWAN (3G) can be
* globally enabled or disabled
*/
ENABLE_DISABLE_WWAN,
/**
* controls whether WiMAX can be
* globally enabled or disabled
*/
ENABLE_DISABLE_WIMAX,
/**
* controls whether the client can ask
* NetworkManager to sleep and wake
*/
SLEEP_WAKE,
/**
* controls whether networking connections
* can be started, stopped, and changed
*/
NETWORK_CONTROL,
/**
* controls whether a password
* protected Wi-Fi hotspot can be created
*/
WIFI_SHARE_PROTECTED,
/**
* controls whether an open Wi-Fi hotspot
* can be created
*/
WIFI_SHARE_OPEN,
/**
* controls whether connections
* that are available to all users can be modified
*/
SETTINGS_MODIFY_SYSTEM,
/**
* controls whether connections
* owned by the current user can be modified
*/
SETTINGS_MODIFY_OWN,
/**
* controls whether the
* persistent hostname can be changed
*/
SETTINGS_MODIFY_HOSTNAME,
/**
* modify persistent global
* DNS configuration
*/
SETTINGS_MODIFY_GLOBAL_DNS,
/**
* controls access to Reload.
*/
RELOAD,
/**
* permission to create checkpoints.
*/
CHECKPOINT_ROLLBACK,
/**
* controls whether device
* statistics can be globally enabled or disabled
*/
ENABLE_DISABLE_STATISTICS,
/**
* controls whether
* connectivity check can be enabled or disabled
*/
ENABLE_DISABLE_CONNECTIVITY_CHECK,
/**
* controls whether wifi scans can be performed
*/
WIFI_SCAN,
/**
* a reserved boundary value
*/
LAST,
}
/**
* #NMClientPermissionResult values indicate what authorizations and permissions
* the user requires to obtain a given #NMClientPermission
*/
/**
* #NMClientPermissionResult values indicate what authorizations and permissions
* the user requires to obtain a given #NMClientPermission
*/
export namespace ClientPermissionResult {
export const $gtype: GObject.GType;
}
enum ClientPermissionResult {
/**
* unknown or no authorization
*/
UNKNOWN,
/**
* the permission is available
*/
YES,
/**
* authorization is necessary before the
* permission is available
*/
AUTH,
/**
* permission to perform the operation is
* denied by system policy
*/
NO,
}
/**
* Describes errors that may result from operations involving a #NMConnection
* or its #NMSettings.
*
* These errors may be returned directly from #NMConnection and #NMSetting
* methods, or may be returned from D-Bus operations (eg on #NMClient or
* #NMDevice), where they correspond to errors in the
* "org.freedesktop.NetworkManager.Settings.Connection" namespace.
*/
class ConnectionError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
/**
* unknown or unclassified error
*/
static FAILED: number;
/**
* the #NMConnection object
* did not contain the specified #NMSetting object
*/
static SETTINGNOTFOUND: number;
/**
* the #NMConnection did not contain the
* requested #NMSetting property
*/
static PROPERTYNOTFOUND: number;
/**
* an operation which requires a secret
* was attempted on a non-secret property
*/
static PROPERTYNOTSECRET: number;
/**
* the #NMConnection object is missing an
* #NMSetting which is required for its configuration. The error message will
* always be prefixed with "<setting-name>: ", where "<setting-name>" is the
* name of the setting that is missing.
*/
static MISSINGSETTING: number;
/**
* the #NMConnection object contains an
* invalid or inappropriate #NMSetting. The error message will always be
* prefixed with "<setting-name>: ", where "<setting-name>" is the name of the
* setting that is invalid.
*/
static INVALIDSETTING: number;
/**
* the #NMConnection object is invalid
* because it is missing a required property. The error message will always be
* prefixed with "<setting-name>.<property-name>: ", where "<setting-name>" is
* the name of the setting with the missing property, and "<property-name>" is
* the property that is missing.
*/
static MISSINGPROPERTY: number;
/**
* the #NMConnection object is invalid
* because a property has an invalid value. The error message will always be
* prefixed with "<setting-name>.<property-name>: ", where "<setting-name>" is
* the name of the setting with the invalid property, and "<property-name>" is
* the property that is invalid.
*/
static INVALIDPROPERTY: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
// Static methods
static quark(): GLib.Quark;
}
export namespace ConnectionMultiConnect {
export const $gtype: GObject.GType;
}
enum ConnectionMultiConnect {
/**
* indicates that the per-connection
* setting is unspecified. In this case, it will fallback to the default
* value, which is %NM_CONNECTION_MULTI_CONNECT_SINGLE.
*/
DEFAULT,
/**
* the connection profile can only
* be active once at each moment. Activating a profile that is already active,
* will first deactivate it.
*/
SINGLE,
/**
* the profile can
* be manually activated multiple times on different devices. However,
* regarding autoconnect, the profile will autoconnect only if it is
* currently not connected otherwise.
*/
MANUAL_MULTIPLE,
/**
* the profile can autoactivate
* and be manually activated multiple times together.
*/
MULTIPLE,
}
export namespace ConnectivityState {
export const $gtype: GObject.GType;
}
enum ConnectivityState {
/**
* Network connectivity is unknown. This means the
* connectivity checks are disabled (e.g. on server installations) or has
* not run yet. The graphical shell should assume the Internet connection
* might be available and not present a captive portal window.
*/
UNKNOWN,
/**
* The host is not connected to any network. There's
* no active connection that contains a default route to the internet and
* thus it makes no sense to even attempt a connectivity check. The graphical
* shell should use this state to indicate the network connection is unavailable.
*/
NONE,
/**
* The Internet connection is hijacked by a captive
* portal gateway. The graphical shell may open a sandboxed web browser window
* (because the captive portals typically attempt a man-in-the-middle attacks
* against the https connections) for the purpose of authenticating to a gateway
* and retrigger the connectivity check with CheckConnectivity() when the
* browser window is dismissed.
*/
PORTAL,
/**
* The host is connected to a network, does not appear
* to be able to reach the full Internet, but a captive portal has not been
* detected.
*/
LIMITED,
/**
* The host is connected to a network, and
* appears to be able to reach the full Internet.
*/
FULL,
}
/**
* Cryptography-related errors that can be returned from some nm-utils methods,
* and some #NMSetting8021x operations.
*/
class CryptoError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
/**
* generic failure
*/
static FAILED: number;
/**
* the certificate or key data provided
* was invalid
*/
static INVALID_DATA: number;
/**
* the password was invalid
*/
static INVALID_PASSWORD: number;
/**
* the data uses an unknown cipher
*/
static UNKNOWN_CIPHER: number;
/**
* decryption failed
*/
static DECRYPTION_FAILED: number;
/**
* encryption failed
*/
static ENCRYPTION_FAILED: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
// Static methods
static quark(): GLib.Quark;
}
/**
* Device-related errors.
*
* These errors may be returned directly from #NMDevice methods, or may be
* returned from D-Bus operations (where they correspond to errors in the
* "org.freedesktop.NetworkManager.Device" namespace).
*/
class DeviceError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
/**
* unknown or unclassified error
*/
static FAILED: number;
/**
* NetworkManager failed to create the device
*/
static CREATIONFAILED: number;
/**
* the specified connection is not valid
*/
static INVALIDCONNECTION: number;
/**
* the specified connection is not
* compatible with this device.
*/
static INCOMPATIBLECONNECTION: number;
/**
* the device does not have an active connection
*/
static NOTACTIVE: number;
/**
* the requested operation is only valid on
* software devices.
*/
static NOTSOFTWARE: number;
/**
* the requested operation is not allowed at
* this time.
*/
static NOTALLOWED: number;
/**
* the "specific object" in the
* activation request (eg, the #NMAccessPoint or #NMWimaxNsp) was not
* found.
*/
static SPECIFICOBJECTNOTFOUND: number;
/**
* the version id did not match.
*/
static VERSIONIDMISMATCH: number;
/**
* the requested operation could not
* be completed due to missing dependencies.
*/
static MISSINGDEPENDENCIES: number;
/**
* invalid argument. Since: 1.16.
*/
static INVALIDARGUMENT: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
// Static methods
static quark(): GLib.Quark;
}
export namespace DeviceState {
export const $gtype: GObject.GType;
}
enum DeviceState {
/**
* the device's state is unknown
*/
UNKNOWN,
/**
* the device is recognized, but not managed by
* NetworkManager
*/
UNMANAGED,
/**
* the device is managed by NetworkManager, but
* is not available for use. Reasons may include the wireless switched off,
* missing firmware, no ethernet carrier, missing supplicant or modem manager,
* etc.
*/
UNAVAILABLE,
/**
* the device can be activated, but is currently
* idle and not connected to a network.
*/
DISCONNECTED,
/**
* the device is preparing the connection to the
* network. This may include operations like changing the MAC address,
* setting physical link properties, and anything else required to connect
* to the requested network.
*/
PREPARE,
/**
* the device is connecting to the requested network.
* This may include operations like associating with the Wi-Fi AP, dialing
* the modem, connecting to the remote Bluetooth device, etc.
*/
CONFIG,
/**
* the device requires more information to continue
* connecting to the requested network. This includes secrets like WiFi
* passphrases, login passwords, PIN codes, etc.
*/
NEED_AUTH,
/**
* the device is requesting IPv4 and/or IPv6
* addresses and routing information from the network.
*/
IP_CONFIG,
/**
* the device is checking whether further action is
* required for the requested network connection. This may include checking
* whether only local network access is available, whether a captive portal
* is blocking access to the Internet, etc.
*/
IP_CHECK,
/**
* the device is waiting for a secondary
* connection (like a VPN) which must activated before the device can be
* activated
*/
SECONDARIES,
/**
* the device has a network connection, either local
* or global.
*/
ACTIVATED,
/**
* a disconnection from the current network
* connection was requested, and the device is cleaning up resources used for
* that connection. The network connection may still be valid.
*/
DEACTIVATING,
/**
* the device failed to connect to the requested
* network and is cleaning up the connection request
*/
FAILED,
}
/**
* Device state change reason codes
*/
/**
* Device state change reason codes
*/
export namespace DeviceStateReason {
export const $gtype: GObject.GType;
}
enum DeviceStateReason {
/**
* No reason given
*/
NONE,
/**
* Unknown error
*/
UNKNOWN,
/**
* Device is now managed
*/
NOW_MANAGED,
/**
* Device is now unmanaged
*/
NOW_UNMANAGED,
/**
* The device could not be readied for configuration
*/
CONFIG_FAILED,
/**
* IP configuration could not be reserved (no available address, timeout, etc)
*/
IP_CONFIG_UNAVAILABLE,
/**
* The IP config is no longer valid
*/
IP_CONFIG_EXPIRED,
/**
* Secrets were required, but not provided
*/
NO_SECRETS,
/**
* 802.1x supplicant disconnected
*/
SUPPLICANT_DISCONNECT,
/**
* 802.1x supplicant configuration failed
*/
SUPPLICANT_CONFIG_FAILED,
/**
* 802.1x supplicant failed
*/
SUPPLICANT_FAILED,
/**
* 802.1x supplicant took too long to authenticate
*/
SUPPLICANT_TIMEOUT,
/**
* PPP service failed to start
*/
PPP_START_FAILED,
/**
* PPP service disconnected
*/
PPP_DISCONNECT,
/**
* PPP failed
*/
PPP_FAILED,
/**
* DHCP client failed to start
*/
DHCP_START_FAILED,
/**
* DHCP client error
*/
DHCP_ERROR,
/**
* DHCP client failed
*/
DHCP_FAILED,
/**
* Shared connection service failed to start
*/
SHARED_START_FAILED,
/**
* Shared connection service failed
*/
SHARED_FAILED,
/**
* AutoIP service failed to start
*/
AUTOIP_START_FAILED,
/**
* AutoIP service error
*/
AUTOIP_ERROR,
/**
* AutoIP service failed
*/
AUTOIP_FAILED,
/**
* The line is busy
*/
MODEM_BUSY,
/**
* No dial tone
*/
MODEM_NO_DIAL_TONE,
/**
* No carrier could be established
*/
MODEM_NO_CARRIER,
/**
* The dialing request timed out
*/
MODEM_DIAL_TIMEOUT,
/**
* The dialing attempt failed
*/
MODEM_DIAL_FAILED,
/**
* Modem initialization failed
*/
MODEM_INIT_FAILED,
/**
* Failed to select the specified APN
*/
GSM_APN_FAILED,
/**
* Not searching for networks
*/
GSM_REGISTRATION_NOT_SEARCHING,
/**
* Network registration denied
*/
GSM_REGISTRATION_DENIED,
/**
* Network registration timed out
*/
GSM_REGISTRATION_TIMEOUT,
/**
* Failed to register with the requested network
*/
GSM_REGISTRATION_FAILED,
/**
* PIN check failed
*/
GSM_PIN_CHECK_FAILED,
/**
* Necessary firmware for the device may be missing
*/
FIRMWARE_MISSING,
/**
* The device was removed
*/
REMOVED,
/**
* NetworkManager went to sleep
*/
SLEEPING,
/**
* The device's active connection disappeared
*/
CONNECTION_REMOVED,
/**
* Device disconnected by user or client
*/
USER_REQUESTED,
/**
* Carrier/link changed
*/
CARRIER,
/**
* The device's existing connection was assumed
*/
CONNECTION_ASSUMED,
/**
* The supplicant is now available
*/
SUPPLICANT_AVAILABLE,
/**
* The modem could not be found
*/
MODEM_NOT_FOUND,
/**
* The Bluetooth connection failed or timed out
*/
BT_FAILED,
/**
* GSM Modem's SIM Card not inserted
*/
GSM_SIM_NOT_INSERTED,
/**
* GSM Modem's SIM Pin required
*/
GSM_SIM_PIN_REQUIRED,
/**
* GSM Modem's SIM Puk required
*/
GSM_SIM_PUK_REQUIRED,
/**
* GSM Modem's SIM wrong
*/
GSM_SIM_WRONG,
/**
* InfiniBand device does not support connected mode
*/
INFINIBAND_MODE,
/**
* A dependency of the connection failed
*/
DEPENDENCY_FAILED,
/**
* Problem with the RFC 2684 Ethernet over ADSL bridge
*/
BR2684_FAILED,
/**
* ModemManager not running
*/
MODEM_MANAGER_UNAVAILABLE,
/**
* The Wi-Fi network could not be found
*/
SSID_NOT_FOUND,
/**
* A secondary connection of the base connection failed
*/
SECONDARY_CONNECTION_FAILED,
/**
* DCB or FCoE setup failed
*/
DCB_FCOE_FAILED,
/**
* teamd control failed
*/
TEAMD_CONTROL_FAILED,
/**
* Modem failed or no longer available
*/
MODEM_FAILED,
/**
* Modem now ready and available
*/
MODEM_AVAILABLE,
/**
* SIM PIN was incorrect
*/
SIM_PIN_INCORRECT,
/**
* New connection activation was enqueued
*/
NEW_ACTIVATION,
/**
* the device's parent changed
*/
PARENT_CHANGED,
/**
* the device parent's management changed
*/
PARENT_MANAGED_CHANGED,
/**
* problem communicating with Open vSwitch database
*/
OVSDB_FAILED,
/**
* a duplicate IP address was detected
*/
IP_ADDRESS_DUPLICATE,
/**
* The selected IP method is not supported
*/
IP_METHOD_UNSUPPORTED,
/**
* configuration of SR-IOV parameters failed
*/
SRIOV_CONFIGURATION_FAILED,
/**
* The Wi-Fi P2P peer could not be found
*/
PEER_NOT_FOUND,
/**
* The device handler dispatcher returned an
* error. Since: 1.46
*/
DEVICE_HANDLER_FAILED,
/**
* The device is unmanaged because the device type
* is unmanaged by default. Since: 1.48
*/
UNMANAGED_BY_DEFAULT,
/**
* The device is unmanaged because it is an
* external device and is unconfigured (down or without addresses). Since: 1.48
*/
UNMANAGED_EXTERNAL_DOWN,
/**
* The device is unmanaged because the link is
* not initialized by udev. Since: 1.48
*/
UNMANAGED_LINK_NOT_INIT,
/**
* The device is unmanaged because NetworkManager is
* quitting. Since: 1.48
*/
UNMANAGED_QUITTING,
/**
* The device is unmanaged because networking is
* disabled or the system is suspended. Since: 1.48
*/
UNMANAGED_SLEEPING,
/**
* The device is unmanaged by user decision in
* NetworkManager.conf ('unmanaged' in a [device*] section). Since: 1.48
*/
UNMANAGED_USER_CONF,
/**
* The device is unmanaged by explicit user
* decision (e.g. 'nmcli device set $DEV managed no'). Since: 1.48
*/
UNMANAGED_USER_EXPLICIT,
/**
* The device is unmanaged by user decision
* via settings plugin ('unmanaged-devices' for keyfile or 'NM_CONTROLLED=no' for ifcfg-rh).
* Since: 1.48
*/
UNMANAGED_USER_SETTINGS,
/**
* The device is unmanaged via udev rule. Since: 1.48
*/
UNMANAGED_USER_UDEV,
}
/**
* #NMDeviceType values indicate the type of hardware represented by a
* device object.
*/
/**
* #NMDeviceType values indicate the type of hardware represented by a
* device object.
*/
export namespace DeviceType {
export const $gtype: GObject.GType;
}
enum DeviceType {
/**
* unknown device
*/
UNKNOWN,
/**
* a wired ethernet device
*/
ETHERNET,
/**
* an 802.11 Wi-Fi device
*/
WIFI,
/**
* not used
*/
UNUSED1,
/**
* not used
*/
UNUSED2,
/**
* a Bluetooth device supporting PAN or DUN access protocols
*/
BT,
/**
* an OLPC XO mesh networking device
*/
OLPC_MESH,
/**
* an 802.16e Mobile WiMAX broadband device
*/
WIMAX,
/**
* a modem supporting analog telephone, CDMA/EVDO,
* GSM/UMTS, or LTE network access protocols
*/
MODEM,
/**
* an IP-over-InfiniBand device
*/
INFINIBAND,
/**
* a bond controller interface
*/
BOND,
/**
* an 802.1Q VLAN interface
*/
VLAN,
/**
* ADSL modem
*/
ADSL,
/**
* a bridge controller interface
*/
BRIDGE,
/**
* generic support for unrecognized device types
*/
GENERIC,
/**
* a team controller interface
*/
TEAM,
/**
* a TUN or TAP interface
*/
TUN,
/**
* a IP tunnel interface
*/
IP_TUNNEL,
/**
* a MACVLAN interface
*/
MACVLAN,
/**
* a VXLAN interface
*/
VXLAN,
/**
* a VETH interface
*/
VETH,
/**
* a MACsec interface
*/
MACSEC,
/**
* a dummy interface
*/
DUMMY,
/**
* a PPP interface
*/
PPP,
/**
* a Open vSwitch interface
*/
OVS_INTERFACE,
/**
* a Open vSwitch port
*/
OVS_PORT,
/**
* a Open vSwitch bridge
*/
OVS_BRIDGE,
/**
* a IEEE 802.15.4 (WPAN) MAC Layer Device
*/
WPAN,
/**
* 6LoWPAN interface
*/
'6LOWPAN',
/**
* a WireGuard interface
*/
WIREGUARD,
/**
* an 802.11 Wi-Fi P2P device. Since: 1.16.
*/
WIFI_P2P,
/**
* A VRF (Virtual Routing and Forwarding) interface. Since: 1.24.
*/
VRF,
/**
* a loopback interface. Since: 1.42.
*/
LOOPBACK,
/**
* A HSR/PRP device. Since: 1.46.
*/
HSR,
/**
* A IPVLAN device. Since: 1.52.
*/
IPVLAN,
}
/**
* The tunneling mode.
*/
/**
* The tunneling mode.
*/
export namespace IPTunnelMode {
export const $gtype: GObject.GType;
}
enum IPTunnelMode {
/**
* Unknown/unset tunnel mode
*/
UNKNOWN,
/**
* IP in IP tunnel
*/
IPIP,
/**
* GRE tunnel
*/
GRE,
/**
* SIT tunnel
*/
SIT,
/**
* ISATAP tunnel
*/
ISATAP,
/**
* VTI tunnel
*/
VTI,
/**
* IPv6 in IPv6 tunnel
*/
IP6IP6,
/**
* IPv4 in IPv6 tunnel
*/
IPIP6,
/**
* IPv6 GRE tunnel
*/
IP6GRE,
/**
* IPv6 VTI tunnel
*/
VTI6,
/**
* GRETAP tunnel
*/
GRETAP,
/**
* IPv6 GRETAP tunnel
*/
IP6GRETAP,
}
/**
* The type of the callback for %NMKeyfileReadHandler and %NMKeyfileWriteHandler.
* Depending on the type, you can interpret %NMKeyfileHandlerData.
*/
/**
* The type of the callback for %NMKeyfileReadHandler and %NMKeyfileWriteHandler.
* Depending on the type, you can interpret %NMKeyfileHandlerData.
*/
export namespace KeyfileHandlerType {
export const $gtype: GObject.GType;
}
enum KeyfileHandlerType {
/**
* a warning.
*/
WARN,
/**
* for handling certificates while writing
* a connection to keyfile.
*/
WRITE_CERT,
}
/**
* The severity level of %NM_KEYFILE_HANDLER_TYPE_WARN events.
*/
/**
* The severity level of %NM_KEYFILE_HANDLER_TYPE_WARN events.
*/
export namespace KeyfileWarnSeverity {
export const $gtype: GObject.GType;
}
enum KeyfileWarnSeverity {
/**
* debug message
*/
DEBUG,
/**
* info message
*/
INFO,
/**
* info message about a missing file
*/
INFO_MISSING_FILE,
/**
* a warning message
*/
WARN,
}
/**
* Errors related to the main "network management" interface of NetworkManager.
* These may be returned from #NMClient methods that invoke D-Bus operations on
* the "org.freedesktop.NetworkManager" interface, and correspond to D-Bus
* errors in that namespace.
*/
class ManagerError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
/**
* unknown or unclassified error
*/
static FAILED: number;
/**
* Permission denied.
*/
static PERMISSIONDENIED: number;
/**
* The requested connection is not known.
*/
static UNKNOWNCONNECTION: number;
/**
* The requested device is not known.
*/
static UNKNOWNDEVICE: number;
/**
* The requested connection cannot be
* activated at this time.
*/
static CONNECTIONNOTAVAILABLE: number;
/**
* The request could not be completed
* because a required connection is not active.
*/
static CONNECTIONNOTACTIVE: number;
/**
* The connection to be activated was
* already active on another device.
*/
static CONNECTIONALREADYACTIVE: number;
/**
* An activation request failed due to a
* dependency being unavailable.
*/
static DEPENDENCYFAILED: number;
/**
* The manager is already in the requested
* sleep/wake state.
*/
static ALREADYASLEEPORAWAKE: number;
/**
* The network is already
* enabled/disabled.
*/
static ALREADYENABLEDORDISABLED: number;
/**
* Unknown log level in SetLogging
*/
static UNKNOWNLOGLEVEL: number;
/**
* Unknown log domain in SetLogging
*/
static UNKNOWNLOGDOMAIN: number;
/**
* Invalid arguments for D-Bus request
*/
static INVALIDARGUMENTS: number;
/**
* A plug-in was needed to complete the
* activation but is not available.
*/
static MISSINGPLUGIN: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
// Static methods
static quark(): GLib.Quark;
}
/**
* The NMMetered enum has two different purposes: one is to configure
* "connection.metered" setting of a connection profile in #NMSettingConnection, and
* the other is to express the actual metered state of the #NMDevice at a given moment.
*
* For the connection profile only #NM_METERED_UNKNOWN, #NM_METERED_NO
* and #NM_METERED_YES are allowed.
*
* The device's metered state at runtime is determined by the profile
* which is currently active. If the profile explicitly specifies #NM_METERED_NO
* or #NM_METERED_YES, then the device's metered state is as such.
* If the connection profile leaves it undecided at #NM_METERED_UNKNOWN (the default),
* then NetworkManager tries to guess the metered state, for example based on the
* device type or on DHCP options (like Android devices exposing a "ANDROID_METERED"
* DHCP vendor option). This then leads to either #NM_METERED_GUESS_NO or #NM_METERED_GUESS_YES.
*
* Most applications probably should treat the runtime state #NM_METERED_GUESS_YES
* like #NM_METERED_YES, and all other states as not metered.
*
* Note that the per-device metered states are then combined to a global metered
* state. This is basically the metered state of the device with the best default
* route. However, that generalization of a global metered state may not be correct
* if the default routes for IPv4 and IPv6 are on different devices, or if policy
* routing is configured. In general, the global metered state tries to express whether
* the traffic is likely metered, but since that depends on the traffic itself,
* there is not one answer in all cases. Hence, an application may want to consider
* the per-device's metered states.
*/
/**
* The NMMetered enum has two different purposes: one is to configure
* "connection.metered" setting of a connection profile in #NMSettingConnection, and
* the other is to express the actual metered state of the #NMDevice at a given moment.
*
* For the connection profile only #NM_METERED_UNKNOWN, #NM_METERED_NO
* and #NM_METERED_YES are allowed.
*
* The device's metered state at runtime is determined by the profile
* which is currently active. If the profile explicitly specifies #NM_METERED_NO
* or #NM_METERED_YES, then the device's metered state is as such.
* If the connection profile leaves it undecided at #NM_METERED_UNKNOWN (the default),
* then NetworkManager tries to guess the metered state, for example based on the
* device type or on DHCP options (like Android devices exposing a "ANDROID_METERED"
* DHCP vendor option). This then leads to either #NM_METERED_GUESS_NO or #NM_METERED_GUESS_YES.
*
* Most applications probably should treat the runtime state #NM_METERED_GUESS_YES
* like #NM_METERED_YES, and all other states as not metered.
*
* Note that the per-device metered states are then combined to a global metered
* state. This is basically the metered state of the device with the best default
* route. However, that generalization of a global metered state may not be correct
* if the default routes for IPv4 and IPv6 are on different devices, or if policy
* routing is configured. In general, the global metered state tries to express whether
* the traffic is likely metered, but since that depends on the traffic itself,
* there is not one answer in all cases. Hence, an application may want to consider
* the per-device's metered states.
*/
export namespace Metered {
export const $gtype: GObject.GType;
}
enum Metered {
/**
* The metered status is unknown
*/
UNKNOWN,
/**
* Metered, the value was explicitly configured
*/
YES,
/**
* Not metered, the value was explicitly configured
*/
NO,
/**
* Metered, the value was guessed
*/
GUESS_YES,
/**
* Not metered, the value was guessed
*/
GUESS_NO,
}
/**
* The result of a checkpoint Rollback() operation for a specific device.
*/
/**
* The result of a checkpoint Rollback() operation for a specific device.
*/
export namespace RollbackResult {
export const $gtype: GObject.GType;
}
enum RollbackResult {
/**
* the rollback succeeded.
*/
OK,
/**
* the device no longer exists.
*/
ERR_NO_DEVICE,
/**
* the device is now unmanaged.
*/
ERR_DEVICE_UNMANAGED,
/**
* other errors during rollback.
*/
ERR_FAILED,
}
/**
* #NMSecretAgentError values are passed by secret agents back to NetworkManager
* when they encounter problems retrieving secrets on behalf of NM. They
* correspond to errors in the "org.freedesktop.NetworkManager.SecretManager"
* namespace.
*
* Client APIs such as nm_client_activate_connection() will not see these error
* codes; instead, the secret agent manager will translate them to the
* corresponding #NMAgentManagerError codes.
*/
class SecretAgentError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
/**
* unknown or unclassified error
*/
static FAILED: number;
/**
* the caller (ie, NetworkManager) is
* not authorized to make this request
*/
static PERMISSIONDENIED: number;
/**
* the connection for which secrets
* were requested is invalid
*/
static INVALIDCONNECTION: number;
/**
* the request was canceled by the user
*/
static USERCANCELED: number;
/**
* the agent canceled the request
* because it was requested to do so by NetworkManager
*/
static AGENTCANCELED: number;
/**
* the agent cannot find any secrets for this
* connection
*/
static NOSECRETS: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
// Static methods
static quark(): GLib.Quark;
}
/**
* #NMSetting8021xCKFormat values indicate the general type of a certificate
* or private key
*/
/**
* #NMSetting8021xCKFormat values indicate the general type of a certificate
* or private key
*/
export namespace Setting8021xCKFormat {
export const $gtype: GObject.GType;
}
enum Setting8021xCKFormat {
/**
* unknown file format
*/
UNKNOWN,
/**
* file contains an X.509 format certificate
*/
X509,
/**
* file contains an old-style OpenSSL PEM
* or DER private key
*/
RAW_KEY,
/**
* file contains a PKCS#12 certificate
* and private key
*/
PKCS12,
}
/**
* #NMSetting8021xCKScheme values indicate how a certificate or private key is
* stored in the setting properties, either as a blob of the item's data, or as
* a path to a certificate or private key file on the filesystem
*/
/**
* #NMSetting8021xCKScheme values indicate how a certificate or private key is
* stored in the setting properties, either as a blob of the item's data, or as
* a path to a certificate or private key file on the filesystem
*/
export namespace Setting8021xCKScheme {
export const $gtype: GObject.GType;
}
enum Setting8021xCKScheme {
/**
* unknown certificate or private key
* scheme
*/
UNKNOWN,
/**
* certificate or key is stored as the raw
* item data
*/
BLOB,
/**
* certificate or key is stored as a path
* to a file containing the certificate or key data
*/
PATH,
/**
* certificate or key is stored as a
* URI of an object on a PKCS#11 token
*/
PKCS11,
}
/**
* These flags modify the comparison behavior when comparing two settings or
* two connections.
*/
/**
* These flags modify the comparison behavior when comparing two settings or
* two connections.
*/
export namespace SettingCompareFlags {
export const $gtype: GObject.GType;
}
enum SettingCompareFlags {
/**
* match all properties exactly
*/
EXACT,
/**
* match only important attributes, like SSID,
* type, security settings, etc. Does not match, for example, connection ID
* or UUID.
*/
FUZZY,
/**
* ignore the connection's ID
*/
IGNORE_ID,
/**
* ignore all secrets
*/
IGNORE_SECRETS,
/**
* ignore secrets for which
* the secret's flags indicate the secret is owned by a user secret agent
* (ie, the secret's flag includes `NM_SETTING_SECRET_FLAG_AGENT_OWNED)`
*/
IGNORE_AGENT_OWNED_SECRETS,
/**
* ignore secrets for which
* the secret's flags indicate the secret should not be saved to persistent
* storage (ie, the secret's flag includes `NM_SETTING_SECRET_FLAG_NOT_SAVED)`
*/
IGNORE_NOT_SAVED_SECRETS,
/**
* if this flag is set,
* nm_setting_diff() and nm_connection_diff() will also include properties that
* are set to their default value. See also `NM_SETTING_COMPARE_FLAG_DIFF_RESULT_NO_DEFAULT`.
*/
DIFF_RESULT_WITH_DEFAULT,
/**
* if this flag is set,
* nm_setting_diff() and nm_connection_diff() will not include properties that
* are set to their default value. This is the opposite of
* `NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT`. If both flags are set together,
* `NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT` wins. If both flags are unset,
* this means to exclude default properties if there is a setting to compare,
* but include all properties, if the setting 'b' is missing. This is the legacy
* behaviour of libnm-util, where nm_setting_diff() behaved differently depending
* on whether the setting 'b' was available. If `NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT`
* is set, nm_setting_diff() will also set the flags `NM_SETTING_DIFF_RESULT_IN_A_DEFAULT`
* and `NM_SETTING_DIFF_RESULT_IN_B_DEFAULT,` if the values are default values.
*/
DIFF_RESULT_NO_DEFAULT,
/**
* ignore the connection's timestamp
*/
IGNORE_TIMESTAMP,
}
/**
* #NMSettingConnectionAutoconnectSlaves values indicate whether slave connections
* should be activated when controller is activated.
*/
/**
* #NMSettingConnectionAutoconnectSlaves values indicate whether slave connections
* should be activated when controller is activated.
*/
export namespace SettingConnectionAutoconnectSlaves {
export const $gtype: GObject.GType;
}
enum SettingConnectionAutoconnectSlaves {
/**
* default value
*/
DEFAULT,
/**
* slaves are not brought up when
* controller is activated
*/
NO,
/**
* slaves are brought up when
* controller is activated
*/
YES,
}
/**
* #NMSettingConnectionDnsOverTls values indicate whether DNSOverTls should be enabled.
*/
/**
* #NMSettingConnectionDnsOverTls values indicate whether DNSOverTls should be enabled.
*/
export namespace SettingConnectionDnsOverTls {
export const $gtype: GObject.GType;
}
enum SettingConnectionDnsOverTls {
/**
* default value
*/
DEFAULT,
/**
* disable DNSOverTls
*/
NO,
/**
* enable opportunistic mode
*/
OPPORTUNISTIC,
/**
* enable strict mode
*/
YES,
}
/**
* #NMSettingConnectionDownOnPoweroff indicates whether the connection will be
* brought down before the system is powered off.
*/
/**
* #NMSettingConnectionDownOnPoweroff indicates whether the connection will be
* brought down before the system is powered off.
*/
export namespace SettingConnectionDownOnPoweroff {
export const $gtype: GObject.GType;
}
enum SettingConnectionDownOnPoweroff {
/**
* default value
*/
DEFAULT,
/**
* disable down-on-poweroff
*/
NO,
/**
* enable down-on-poweroff
*/
YES,
}
/**
* #NMSettingConnectionLldp values indicate whether LLDP should be enabled.
*/
/**
* #NMSettingConnectionLldp values indicate whether LLDP should be enabled.
*/
export namespace SettingConnectionLldp {
export const $gtype: GObject.GType;
}
enum SettingConnectionLldp {
/**
* default value
*/
DEFAULT,
/**
* disable LLDP
*/
DISABLE,
/**
* enable reception of LLDP frames
*/
ENABLE_RX,
}
/**
* #NMSettingConnectionLlmnr values indicate whether LLMNR should be enabled.
*/
/**
* #NMSettingConnectionLlmnr values indicate whether LLMNR should be enabled.
*/
export namespace SettingConnectionLlmnr {
export const $gtype: GObject.GType;
}
enum SettingConnectionLlmnr {
/**
* default value
*/
DEFAULT,
/**
* disable LLMNR
*/
NO,
/**
* support only resolving, do not register hostname
*/
RESOLVE,
/**
* enable LLMNR
*/
YES,
}
/**
* #NMSettingConnectionMdns values indicate whether mDNS should be enabled.
*/
/**
* #NMSettingConnectionMdns values indicate whether mDNS should be enabled.
*/
export namespace SettingConnectionMdns {
export const $gtype: GObject.GType;
}
enum SettingConnectionMdns {
/**
* default value
*/
DEFAULT,
/**
* disable mDNS
*/
NO,
/**
* support only resolving, do not register hostname
*/
RESOLVE,
/**
* enable mDNS
*/
YES,
}
/**
* These values indicate the result of a setting difference operation.
*/
/**
* These values indicate the result of a setting difference operation.
*/
export namespace SettingDiffResult {
export const $gtype: GObject.GType;
}
enum SettingDiffResult {
/**
* unknown result
*/
UNKNOWN,
/**
* the property is present in setting A
*/
IN_A,
/**
* the property is present in setting B
*/
IN_B,
/**
* the property is present in
* setting A but is set to the default value. This flag is only set,
* if you specify `NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT`.
*/
IN_A_DEFAULT,
/**
* analog to `NM_SETTING_DIFF_RESULT_IN_A_DEFAULT`.
*/
IN_B_DEFAULT,
}
/**
* #NMSettingIP4DhcpIpv6OnlyPreferred values specify if the "IPv6-Only Preferred"
* option (RFC 8925) for DHCPv4 is enabled.
*/
/**
* #NMSettingIP4DhcpIpv6OnlyPreferred values specify if the "IPv6-Only Preferred"
* option (RFC 8925) for DHCPv4 is enabled.
*/
export namespace SettingIP4DhcpIpv6OnlyPreferred {
export const $gtype: GObject.GType;
}
enum SettingIP4DhcpIpv6OnlyPreferred {
/**
* use the global default value
*/
DEFAULT,
/**
* the option is disabled
*/
NO,
/**
* the option is enabled
*/
YES,
}
/**
* #NMSettingIP4LinkLocal values indicate whether IPv4 link-local address protocol should be enabled.
*/
/**
* #NMSettingIP4LinkLocal values indicate whether IPv4 link-local address protocol should be enabled.
*/
export namespace SettingIP4LinkLocal {
export const $gtype: GObject.GType;
}
enum SettingIP4LinkLocal {
/**
* Allow fallback to a globally configured default. If unspecified,
* fallback to "auto". Note that if "ipv4.method" is "disabled", this always implies link-local
* addresses disabled too.
*/
DEFAULT,
/**
* Special value which enables LL if "ipv4.method" is set to
* "link-local".
*/
AUTO,
/**
* Disable IPv4 link-local protocol.
*/
DISABLED,
/**
* Enable the IPv4 link-local protocol regardless what other protocols
* such as DHCP or manually assigned IP addresses might be active.
*/
ENABLED,
/**
* Since 1.52. This sets an IPv4 link-local address if no other IPv4
* address is set, dynamically removing/re-adding it depending on DHCP leases.
*/
FALLBACK,
}
/**
* #NMSettingIP6ConfigAddrGenMode controls how the Interface Identifier for
* RFC4862 Stateless Address Autoconfiguration is created.
*/
/**
* #NMSettingIP6ConfigAddrGenMode controls how the Interface Identifier for
* RFC4862 Stateless Address Autoconfiguration is created.
*/
export namespace SettingIP6ConfigAddrGenMode {
export const $gtype: GObject.GType;
}
enum SettingIP6ConfigAddrGenMode {
/**
* The Interface Identifier is derived
* from the interface hardware address.
*/
EUI64,
/**
* The Interface Identifier
* is created by using a cryptographically secure hash of a secret host-specific
* key along with the connection identification and the network address as
* specified by RFC7217.
*/
STABLE_PRIVACY,
/**
* Fallback to the global
* default, and if unspecified use "eui64". Since: 1.40.
*/
DEFAULT_OR_EUI64,
/**
* Fallback to the global
* default, and if unspecified use "stable-privacy". Since: 1.40.
*/
DEFAULT,
}
/**
* #NMSettingIP6ConfigPrivacy values indicate if and how IPv6 Privacy
* Extensions are used (RFC4941).
*/
/**
* #NMSettingIP6ConfigPrivacy values indicate if and how IPv6 Privacy
* Extensions are used (RFC4941).
*/
export namespace SettingIP6ConfigPrivacy {
export const $gtype: GObject.GType;
}
enum SettingIP6ConfigPrivacy {
/**
* unknown or no value specified
*/
UNKNOWN,
/**
* IPv6 Privacy Extensions are disabled
*/
DISABLED,
/**
* IPv6 Privacy Extensions
* are enabled, but public addresses are preferred over temporary addresses
*/
PREFER_PUBLIC_ADDR,
/**
* IPv6 Privacy Extensions
* are enabled and temporary addresses are preferred over public addresses
*/
PREFER_TEMP_ADDR,
}
/**
* #NMSettingIPConfigRoutedDns indicates whether routes are added
* automatically for each DNS that is associated with this connection.
*/
/**
* #NMSettingIPConfigRoutedDns indicates whether routes are added
* automatically for each DNS that is associated with this connection.
*/
export namespace SettingIPConfigRoutedDns {
export const $gtype: GObject.GType;
}
enum SettingIPConfigRoutedDns {
/**
* use the global default value
*/
DEFAULT,
/**
* do not add DNS routes
*/
NO,
/**
* do add DNS routes
*/
YES,
}
export namespace SettingIpvlanMode {
export const $gtype: GObject.GType;
}
enum SettingIpvlanMode {
/**
* unknown/unset mode
*/
UNKNOWN,
/**
* L2 mode, device receives and responds to ARP.
*/
L2,
/**
* L3 mode, device process only L3 traffic and above.
*/
L3,
/**
* L3S mode, same way as L3 mode but egress and ingress
* lands on netfilter chain.
*/
L3S,
}
/**
* Controls if and how the MAC address of a device is randomzied.
*/
/**
* Controls if and how the MAC address of a device is randomzied.
*/
export namespace SettingMacRandomization {
export const $gtype: GObject.GType;
}
enum SettingMacRandomization {
/**
* the default value, which unless
* overridden by user-controlled defaults configuration, is "never".
*/
DEFAULT,
/**
* the device's MAC address is always used.
*/
NEVER,
/**
* a random MAC address is used.
*/
ALWAYS,
}
/**
* #NMSettingMacsecMode controls how the CAK (Connectivity Association Key) used
* in MKA (MACsec Key Agreement) is obtained.
*/
/**
* #NMSettingMacsecMode controls how the CAK (Connectivity Association Key) used
* in MKA (MACsec Key Agreement) is obtained.
*/
export namespace SettingMacsecMode {
export const $gtype: GObject.GType;
}
enum SettingMacsecMode {
/**
* The CAK is pre-shared
*/
PSK,
/**
* The CAK is the result of participation in EAP
*/
EAP,
}
/**
* These flags control the MACsec offload mode.
*/
/**
* These flags control the MACsec offload mode.
*/
export namespace SettingMacsecOffload {
export const $gtype: GObject.GType;
}
enum SettingMacsecOffload {
/**
* use the global default; disable if not defined
*/
DEFAULT,
/**
* disable offload
*/
OFF,
/**
* request offload to the PHY
*/
PHY,
/**
* request offload to the MAC
*/
MAC,
}
/**
* #NMSettingMacsecValidation specifies a validation mode for incoming frames.
*/
/**
* #NMSettingMacsecValidation specifies a validation mode for incoming frames.
*/
export namespace SettingMacsecValidation {
export const $gtype: GObject.GType;
}
enum SettingMacsecValidation {
/**
* All incoming frames are accepted if
* possible
*/
DISABLE,
/**
* Non protected, invalid, or impossible to
* verify frames are accepted and counted as "invalid"
*/
CHECK,
/**
* Non protected, invalid, or impossible to
* verify frames are dropped
*/
STRICT,
}
export namespace SettingMacvlanMode {
export const $gtype: GObject.GType;
}
enum SettingMacvlanMode {
/**
* unknown/unset mode
*/
UNKNOWN,
/**
* Virtual Ethernet Port Aggregator mode
*/
VEPA,
/**
* bridge mode
*/
BRIDGE,
/**
* private mode
*/
PRIVATE,
/**
* passthru mode
*/
PASSTHRU,
/**
* source mode
*/
SOURCE,
}
/**
* The Proxy method.
*/
/**
* The Proxy method.
*/
export namespace SettingProxyMethod {
export const $gtype: GObject.GType;
}
enum SettingProxyMethod {
/**
* No Proxy for the Connection
*/
NONE,
/**
* DHCP obtained Proxy/ Manual override
*/
AUTO,
}
/**
* The parity setting of a serial port.
*/
/**
* The parity setting of a serial port.
*/
export namespace SettingSerialParity {
export const $gtype: GObject.GType;
}
enum SettingSerialParity {
/**
* No parity bits (default)
*/
NONE,
/**
* Even parity
*/
EVEN,
/**
* Odd parity
*/
ODD,
}
/**
* #NMSettingTunMode values indicate the device type (TUN/TAP)
*/
/**
* #NMSettingTunMode values indicate the device type (TUN/TAP)
*/
export namespace SettingTunMode {
export const $gtype: GObject.GType;
}
enum SettingTunMode {
/**
* an unknown device type
*/
UNKNOWN,
/**
* a TUN device
*/
TUN,
/**
* a TAP device
*/
TAP,
}
/**
* Indicates the wireless channel width.
*/
/**
* Indicates the wireless channel width.
*/
export namespace SettingWirelessChannelWidth {
export const $gtype: GObject.GType;
}
enum SettingWirelessChannelWidth {
/**
* automatically determine the width
*/
AUTO,
/**
* use a 20MHz channel width
*/
'20MHZ',
/**
* use a 40MHz channel width
*/
'40MHZ',
/**
* use a 80MHz channel width
*/
'80MHZ',
}
/**
* These flags indicate whether wireless powersave must be enabled.
*/
/**
* These flags indicate whether wireless powersave must be enabled.
*/
export namespace SettingWirelessPowersave {
export const $gtype: GObject.GType;
}
enum SettingWirelessPowersave {
/**
* use the default value
*/
DEFAULT,
/**
* don't touch existing setting
*/
IGNORE,
/**
* disable powersave
*/
DISABLE,
/**
* enable powersave
*/
ENABLE,
}
/**
* These flags indicate whether FILS must be enabled.
*/
/**
* These flags indicate whether FILS must be enabled.
*/
export namespace SettingWirelessSecurityFils {
export const $gtype: GObject.GType;
}
enum SettingWirelessSecurityFils {
/**
* use the default value
*/
DEFAULT,
/**
* disable FILS
*/
DISABLE,
/**
* enable FILS if the supplicant and the AP support it
*/
OPTIONAL,
/**
* require FILS and fail if not available
*/
REQUIRED,
}
/**
* These flags indicate whether PMF must be enabled.
*/
/**
* These flags indicate whether PMF must be enabled.
*/
export namespace SettingWirelessSecurityPmf {
export const $gtype: GObject.GType;
}
enum SettingWirelessSecurityPmf {
/**
* use the default value
*/
DEFAULT,
/**
* disable PMF
*/
DISABLE,
/**
* enable PMF if the supplicant and the AP support it
*/
OPTIONAL,
/**
* require PMF and fail if not available
*/
REQUIRED,
}
/**
* Errors related to the settings/persistent configuration interface of
* NetworkManager.
*
* These may be returned from #NMClient methods that invoke D-Bus operations on
* the "org.freedesktop.NetworkManager.Settings" interface, and correspond to
* D-Bus errors in that namespace.
*/
class SettingsError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
/**
* unknown or unclassified error
*/
static FAILED: number;
/**
* permission denied
*/
static PERMISSIONDENIED: number;
/**
* the requested operation is not supported by any
* active settings backend
*/
static NOTSUPPORTED: number;
/**
* the connection was invalid
*/
static INVALIDCONNECTION: number;
/**
* attempted to modify a read-only connection
*/
static READONLYCONNECTION: number;
/**
* a connection with that UUID already exists
*/
static UUIDEXISTS: number;
/**
* attempted to set an invalid hostname
*/
static INVALIDHOSTNAME: number;
/**
* invalid arguments
*/
static INVALIDARGUMENTS: number;
/**
* The profile's VersionId mismatched
* and the update is rejected. See the "version-id" argument to Update2()
* method. Since 1.44.
*/
static VERSIONIDMISMATCH: number;
/**
* the requested operation is not
* supported by the settings plugin currently in use for the specified object.
* Since: 1.44.
*/
static NOTSUPPORTEDBYPLUGIN: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
// Static methods
static quark(): GLib.Quark;
}
export namespace SriovEswitchEncapMode {
export const $gtype: GObject.GType;
}
enum SriovEswitchEncapMode {
/**
* don't modify current encap-mode
*/
PRESERVE,
/**
* disable encapsulation mode
*/
NONE,
/**
* enable encapsulation mode
*/
BASIC,
}
export namespace SriovEswitchInlineMode {
export const $gtype: GObject.GType;
}
enum SriovEswitchInlineMode {
/**
* don't modify current inline-mode
*/
PRESERVE,
/**
* don't use inline mode
*/
NONE,
/**
* L2 mode
*/
LINK,
/**
* L3 mode
*/
NETWORK,
/**
* L4 mode
*/
TRANSPORT,
}
export namespace SriovEswitchMode {
export const $gtype: GObject.GType;
}
enum SriovEswitchMode {
/**
* don't modify current eswitch mode
*/
PRESERVE,
/**
* use legacy SRIOV
*/
LEGACY,
/**
* use switchdev mode
*/
SWITCHDEV,
}
/**
* #NMSriovVFVlanProtocol indicates the VLAN protocol to use.
*/
/**
* #NMSriovVFVlanProtocol indicates the VLAN protocol to use.
*/
export namespace SriovVFVlanProtocol {
export const $gtype: GObject.GType;
}
enum SriovVFVlanProtocol {
/**
* use 802.1Q
*/
'1Q',
/**
* use 802.1ad
*/
'1AD',
}
/**
* #NMState values indicate the current overall networking state.
*/
/**
* #NMState values indicate the current overall networking state.
*/
export namespace State {
export const $gtype: GObject.GType;
}
enum State {
/**
* Networking state is unknown. This indicates a daemon error
* that makes it unable to reasonably assess the state. In such event the
* applications are expected to assume Internet connectivity might be present
* and not disable controls that require network access.
* The graphical shells may hide the network accessibility indicator altogether
* since no meaningful status indication can be provided.
*/
UNKNOWN,
/**
* Networking is not enabled, the system is being suspended or
* resumed from suspend.
*/
ASLEEP,
/**
* There is no active network connection.
* The graphical shell should indicate no network connectivity and the
* applications should not attempt to access the network.
*/
DISCONNECTED,
/**
* Network connections are being cleaned up.
* The applications should tear down their network sessions.
*/
DISCONNECTING,
/**
* A network connection is being started
* The graphical shell should indicate the network is being connected while
* the applications should still make no attempts to connect the network.
*/
CONNECTING,
/**
* There is only local IPv4 and/or IPv6 connectivity,
* but no default route to access the Internet. The graphical shell should
* indicate no network connectivity.
*/
CONNECTED_LOCAL,
/**
* There is only site-wide IPv4 and/or IPv6 connectivity.
* This means a default route is available, but the Internet connectivity check
* (see "Connectivity" property) did not succeed. The graphical shell should
* indicate limited network connectivity.
*/
CONNECTED_SITE,
/**
* There is global IPv4 and/or IPv6 Internet connectivity
* This means the Internet connectivity check succeeded, the graphical shell should
* indicate full network connectivity.
*/
CONNECTED_GLOBAL,
}
/**
* An boolean value that can be overridden by a default.
*/
/**
* An boolean value that can be overridden by a default.
*/
export namespace Ternary {
export const $gtype: GObject.GType;
}
enum Ternary {
/**
* use the globally-configured default value.
*/
DEFAULT,
/**
* the option is disabled.
*/
FALSE,
/**
* the option is enabled.
*/
TRUE,
}
/**
* Describes generic security mechanisms that 802.11 access points may offer.
* Used with nm_utils_security_valid() for checking whether a given access
* point is compatible with a network device.
*/
/**
* Describes generic security mechanisms that 802.11 access points may offer.
* Used with nm_utils_security_valid() for checking whether a given access
* point is compatible with a network device.
*/
export namespace UtilsSecurityType {
export const $gtype: GObject.GType;
}
enum UtilsSecurityType {
/**
* unknown or invalid security, placeholder and not used
*/
INVALID,
/**
* unencrypted and open
*/
NONE,
/**
* static WEP keys are used for encryption
*/
STATIC_WEP,
/**
* Cisco LEAP is used for authentication and for generating the
* dynamic WEP keys automatically
*/
LEAP,
/**
* standard 802.1x is used for authentication and
* generating the dynamic WEP keys automatically
*/
DYNAMIC_WEP,
/**
* WPA1 is used with Pre-Shared Keys (PSK)
*/
WPA_PSK,
/**
* WPA1 is used with 802.1x authentication
*/
WPA_ENTERPRISE,
/**
* WPA2/RSN is used with Pre-Shared Keys (PSK)
*/
WPA2_PSK,
/**
* WPA2 is used with 802.1x authentication
*/
WPA2_ENTERPRISE,
/**
* is used with WPA3 Enterprise
*/
SAE,
/**
* is used with Enhanced Open
*/
OWE,
/**
* is used with WPA3 Enterprise Suite-B 192 bit mode. Since: 1.30.
*/
WPA3_SUITE_B_192,
}
/**
* The numeric values represent the bit index of the capability. These capabilities
* can be queried in the "VersionInfo" D-Bus property.
*/
/**
* The numeric values represent the bit index of the capability. These capabilities
* can be queried in the "VersionInfo" D-Bus property.
*/
export namespace VersionInfoCapability {
export const $gtype: GObject.GType;
}
enum VersionInfoCapability {
/**
* Contains the fix to a bug that
* caused that routes in table other than main were not removed on reapply nor
* on connection down.
* https://issues.redhat.com/browse/RHEL-66262
* https://issues.redhat.com/browse/RHEL-67324
*/
TABLE,
}
/**
* A selector for traffic priority maps; these map Linux SKB priorities
* to 802.1p priorities used in VLANs.
*/
/**
* A selector for traffic priority maps; these map Linux SKB priorities
* to 802.1p priorities used in VLANs.
*/
export namespace VlanPriorityMap {
export const $gtype: GObject.GType;
}
enum VlanPriorityMap {
/**
* map for incoming data
*/
INGRESS_MAP,
/**
* map for outgoing data
*/
EGRESS_MAP,
}
/**
* VPN connection states
*/
/**
* VPN connection states
*/
export namespace VpnConnectionState {
export const $gtype: GObject.GType;
}
enum VpnConnectionState {
/**
* The state of the VPN connection is
* unknown.
*/
UNKNOWN,
/**
* The VPN connection is preparing to
* connect.
*/
PREPARE,
/**
* The VPN connection needs authorization
* credentials.
*/
NEED_AUTH,
/**
* The VPN connection is being established.
*/
CONNECT,
/**
* The VPN connection is getting an IP
* address.
*/
IP_CONFIG_GET,
/**
* The VPN connection is active.
*/
ACTIVATED,
/**
* The VPN connection failed.
*/
FAILED,
/**
* The VPN connection is disconnected.
*/
DISCONNECTED,
}
/**
* VPN connection state reasons
*/
/**
* VPN connection state reasons
*/
export namespace VpnConnectionStateReason {
export const $gtype: GObject.GType;
}
enum VpnConnectionStateReason {
/**
* The reason for the VPN connection
* state change is unknown.
*/
UNKNOWN,
/**
* No reason was given for the VPN
* connection state change.
*/
NONE,
/**
* The VPN connection changed
* state because the user disconnected it.
*/
USER_DISCONNECTED,
/**
* The VPN connection
* changed state because the device it was using was disconnected.
*/
DEVICE_DISCONNECTED,
/**
* The service providing the
* VPN connection was stopped.
*/
SERVICE_STOPPED,
/**
* The IP config of the VPN
* connection was invalid.
*/
IP_CONFIG_INVALID,
/**
* The connection attempt to
* the VPN service timed out.
*/
CONNECT_TIMEOUT,
/**
* A timeout occurred
* while starting the service providing the VPN connection.
*/
SERVICE_START_TIMEOUT,
/**
* Starting the service
* starting the service providing the VPN connection failed.
*/
SERVICE_START_FAILED,
/**
* Necessary secrets for the VPN
* connection were not provided.
*/
NO_SECRETS,
/**
* Authentication to the VPN
* server failed.
*/
LOGIN_FAILED,
/**
* The connection was
* deleted from settings.
*/
CONNECTION_REMOVED,
}
/**
* Returned by the VPN service plugin to indicate errors. These codes correspond
* to errors in the "org.freedesktop.NetworkManager.VPN.Error" namespace.
*/
class VpnPluginError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
/**
* unknown or unclassified error
*/
static FAILED: number;
/**
* the plugin is already starting,
* and another connect request was received
*/
static STARTINGINPROGRESS: number;
/**
* the plugin is already connected, and
* another connect request was received
*/
static ALREADYSTARTED: number;
/**
* the plugin is already stopping,
* and another stop request was received
*/
static STOPPINGINPROGRESS: number;
/**
* the plugin is already stopped, and
* another disconnect request was received
*/
static ALREADYSTOPPED: number;
/**
* the operation could not be performed in
* this state
*/
static WRONGSTATE: number;
/**
* the operation could not be performed as
* the request contained malformed arguments, or arguments of unexpected type.
* Usually means that one of the VPN setting data items or secrets was not of
* the expected type (ie int, string, bool, etc).
*/
static BADARGUMENTS: number;
/**
* a child process failed to launch
*/
static LAUNCHFAILED: number;
/**
* the operation could not be performed
* because the connection was invalid. Usually means that the connection's
* VPN setting was missing some required data item or secret.
*/
static INVALIDCONNECTION: number;
/**
* the operation could not be
* performed as the plugin does not support interactive operations, such as
* ConnectInteractive() or NewSecrets()
*/
static INTERACTIVENOTSUPPORTED: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
// Static methods
static quark(): GLib.Quark;
}
/**
* VPN plugin failure reasons
*/
/**
* VPN plugin failure reasons
*/
export namespace VpnPluginFailure {
export const $gtype: GObject.GType;
}
enum VpnPluginFailure {
/**
* Login failed.
*/
LOGIN_FAILED,
/**
* Connect failed.
*/
CONNECT_FAILED,
/**
* Invalid IP configuration returned from
* the VPN plugin.
*/
BAD_IP_CONFIG,
}
/**
* VPN daemon states
*/
/**
* VPN daemon states
*/
export namespace VpnServiceState {
export const $gtype: GObject.GType;
}
enum VpnServiceState {
/**
* The state of the VPN plugin is unknown.
*/
UNKNOWN,
/**
* The VPN plugin is initialized.
*/
INIT,
/**
* Not used.
*/
SHUTDOWN,
/**
* The plugin is attempting to connect to a VPN server.
*/
STARTING,
/**
* The plugin has connected to a VPN server.
*/
STARTED,
/**
* The plugin is disconnecting from the VPN server.
*/
STOPPING,
/**
* The plugin has disconnected from the VPN server.
*/
STOPPED,
}
/**
* The #NMWepKeyType values specify how any WEP keys present in the setting
* are interpreted. There are no standards governing how to hash the various WEP
* key/passphrase formats into the actual WEP key. Unfortunately some WEP keys
* can be interpreted in multiple ways, requiring the setting to specify how to
* interpret the any WEP keys. For example, the key "732f2d712e4a394a375d366931"
* is both a valid Hexadecimal WEP key and a WEP passphrase. Further, many
* ASCII keys are also valid WEP passphrases, but since passphrases and ASCII
* keys are hashed differently to determine the actual WEP key the type must be
* specified.
*/
/**
* The #NMWepKeyType values specify how any WEP keys present in the setting
* are interpreted. There are no standards governing how to hash the various WEP
* key/passphrase formats into the actual WEP key. Unfortunately some WEP keys
* can be interpreted in multiple ways, requiring the setting to specify how to
* interpret the any WEP keys. For example, the key "732f2d712e4a394a375d366931"
* is both a valid Hexadecimal WEP key and a WEP passphrase. Further, many
* ASCII keys are also valid WEP passphrases, but since passphrases and ASCII
* keys are hashed differently to determine the actual WEP key the type must be
* specified.
*/
export namespace WepKeyType {
export const $gtype: GObject.GType;
}
enum WepKeyType {
/**
* unknown WEP key type
*/
UNKNOWN,
/**
* indicates a hexadecimal or ASCII formatted WEP key.
* Hex keys are either 10 or 26 hexadecimal characters (ie "5f782f2f5f" or
* "732f2d712e4a394a375d366931"), while ASCII keys are either 5 or 13 ASCII
* characters (ie "abcde" or "blahblah99$*1").
*/
KEY,
/**
* indicates a WEP passphrase (ex "I bought a duck
* on my way back from the market 235Q&^%^*%") instead of a hexadecimal or ASCII
* key. Passphrases are between 8 and 64 characters inclusive and are hashed
* the actual WEP key using the MD5 hash algorithm.
*/
PASSPHRASE,
}
/**
* WiMAX network type.
*/
/**
* WiMAX network type.
*/
export namespace WimaxNspNetworkType {
export const $gtype: GObject.GType;
}
enum WimaxNspNetworkType {
/**
* unknown network type
*/
UNKNOWN,
/**
* home network
*/
HOME,
/**
* partner network
*/
PARTNER,
/**
* roaming partner network
*/
ROAMING_PARTNER,
}
const ACCESS_POINT_BANDWIDTH: string;
const ACCESS_POINT_BSSID: string;
const ACCESS_POINT_FLAGS: string;
const ACCESS_POINT_FREQUENCY: string;
const ACCESS_POINT_HW_ADDRESS: string;
const ACCESS_POINT_LAST_SEEN: string;
const ACCESS_POINT_MAX_BITRATE: string;
const ACCESS_POINT_MODE: string;
const ACCESS_POINT_RSN_FLAGS: string;
const ACCESS_POINT_SSID: string;
const ACCESS_POINT_STRENGTH: string;
const ACCESS_POINT_WPA_FLAGS: string;
const ACTIVE_CONNECTION_CONNECTION: string;
const ACTIVE_CONNECTION_CONTROLLER: string;
const ACTIVE_CONNECTION_DEFAULT: string;
const ACTIVE_CONNECTION_DEFAULT6: string;
const ACTIVE_CONNECTION_DEVICES: string;
const ACTIVE_CONNECTION_DHCP4_CONFIG: string;
const ACTIVE_CONNECTION_DHCP6_CONFIG: string;
const ACTIVE_CONNECTION_ID: string;
const ACTIVE_CONNECTION_IP4_CONFIG: string;
const ACTIVE_CONNECTION_IP6_CONFIG: string;
const ACTIVE_CONNECTION_MASTER: string;
const ACTIVE_CONNECTION_SPECIFIC_OBJECT_PATH: string;
const ACTIVE_CONNECTION_STATE: string;
const ACTIVE_CONNECTION_STATE_FLAGS: string;
const ACTIVE_CONNECTION_TYPE: string;
const ACTIVE_CONNECTION_UUID: string;
const ACTIVE_CONNECTION_VPN: string;
const BRIDGE_VLAN_VID_MAX: number;
const BRIDGE_VLAN_VID_MIN: number;
const CHECKPOINT_CREATED: string;
const CHECKPOINT_DEVICES: string;
const CHECKPOINT_ROLLBACK_TIMEOUT: string;
const CLIENT_ACTIVATING_CONNECTION: string;
const CLIENT_ACTIVE_CONNECTIONS: string;
const CLIENT_ACTIVE_CONNECTION_ADDED: string;
const CLIENT_ACTIVE_CONNECTION_REMOVED: string;
const CLIENT_ALL_DEVICES: string;
const CLIENT_ANY_DEVICE_ADDED: string;
const CLIENT_ANY_DEVICE_REMOVED: string;
const CLIENT_CAN_MODIFY: string;
const CLIENT_CAPABILITIES: string;
const CLIENT_CHECKPOINTS: string;
const CLIENT_CONNECTIONS: string;
const CLIENT_CONNECTION_ADDED: string;
const CLIENT_CONNECTION_REMOVED: string;
const CLIENT_CONNECTIVITY: string;
const CLIENT_CONNECTIVITY_CHECK_AVAILABLE: string;
const CLIENT_CONNECTIVITY_CHECK_ENABLED: string;
const CLIENT_CONNECTIVITY_CHECK_URI: string;
const CLIENT_DBUS_CONNECTION: string;
const CLIENT_DBUS_NAME_OWNER: string;
const CLIENT_DEVICES: string;
const CLIENT_DEVICE_ADDED: string;
const CLIENT_DEVICE_REMOVED: string;
const CLIENT_DNS_CONFIGURATION: string;
const CLIENT_DNS_MODE: string;
const CLIENT_DNS_RC_MANAGER: string;
const CLIENT_HOSTNAME: string;
const CLIENT_INSTANCE_FLAGS: string;
const CLIENT_METERED: string;
const CLIENT_NETWORKING_ENABLED: string;
const CLIENT_NM_RUNNING: string;
const CLIENT_PERMISSIONS_STATE: string;
const CLIENT_PERMISSION_CHANGED: string;
const CLIENT_PRIMARY_CONNECTION: string;
const CLIENT_RADIO_FLAGS: string;
const CLIENT_STARTUP: string;
const CLIENT_STATE: string;
const CLIENT_VERSION: string;
const CLIENT_VERSION_INFO: string;
const CLIENT_WIMAX_ENABLED: string;
const CLIENT_WIMAX_HARDWARE_ENABLED: string;
const CLIENT_WIRELESS_ENABLED: string;
const CLIENT_WIRELESS_HARDWARE_ENABLED: string;
const CLIENT_WWAN_ENABLED: string;
const CLIENT_WWAN_HARDWARE_ENABLED: string;
const CONNECTION_CHANGED: string;
const CONNECTION_NORMALIZE_PARAM_IP4_CONFIG_METHOD: string;
const CONNECTION_NORMALIZE_PARAM_IP6_CONFIG_METHOD: string;
const CONNECTION_SECRETS_CLEARED: string;
const CONNECTION_SECRETS_UPDATED: string;
const DBUS_INTERFACE: string;
const DBUS_INTERFACE_DNS_MANAGER: string;
const DBUS_INTERFACE_SETTINGS: string;
const DBUS_INTERFACE_SETTINGS_CONNECTION: string;
const DBUS_INTERFACE_SETTINGS_CONNECTION_SECRETS: string;
const DBUS_INTERFACE_VPN: string;
const DBUS_INTERFACE_VPN_CONNECTION: string;
const DBUS_INVALID_VPN_CONNECTION: string;
const DBUS_NO_ACTIVE_VPN_CONNECTION: string;
const DBUS_NO_VPN_CONNECTIONS: string;
const DBUS_PATH: string;
const DBUS_PATH_AGENT_MANAGER: string;
const DBUS_PATH_DNS_MANAGER: string;
const DBUS_PATH_SECRET_AGENT: string;
const DBUS_PATH_SETTINGS: string;
const DBUS_PATH_SETTINGS_CONNECTION: string;
const DBUS_PATH_VPN: string;
const DBUS_PATH_VPN_CONNECTION: string;
const DBUS_SERVICE: string;
const DBUS_VPN_ALREADY_STARTED: string;
const DBUS_VPN_ALREADY_STOPPED: string;
const DBUS_VPN_BAD_ARGUMENTS: string;
const DBUS_VPN_ERROR_PREFIX: string;
const DBUS_VPN_INTERACTIVE_NOT_SUPPORTED: string;
const DBUS_VPN_SIGNAL_CONNECT_FAILED: string;
const DBUS_VPN_SIGNAL_IP4_CONFIG: string;
const DBUS_VPN_SIGNAL_IP_CONFIG_BAD: string;
const DBUS_VPN_SIGNAL_LAUNCH_FAILED: string;
const DBUS_VPN_SIGNAL_LOGIN_BANNER: string;
const DBUS_VPN_SIGNAL_LOGIN_FAILED: string;
const DBUS_VPN_SIGNAL_STATE_CHANGE: string;
const DBUS_VPN_SIGNAL_VPN_CONFIG_BAD: string;
const DBUS_VPN_STARTING_IN_PROGRESS: string;
const DBUS_VPN_STOPPING_IN_PROGRESS: string;
const DBUS_VPN_WRONG_STATE: string;
const DEVICE_6LOWPAN_HW_ADDRESS: string;
const DEVICE_6LOWPAN_PARENT: string;
const DEVICE_ACTIVE_CONNECTION: string;
const DEVICE_ADSL_CARRIER: string;
const DEVICE_AUTOCONNECT: string;
const DEVICE_AVAILABLE_CONNECTIONS: string;
const DEVICE_BOND_CARRIER: string;
const DEVICE_BOND_HW_ADDRESS: string;
const DEVICE_BOND_SLAVES: string;
const DEVICE_BRIDGE_CARRIER: string;
const DEVICE_BRIDGE_HW_ADDRESS: string;
const DEVICE_BRIDGE_SLAVES: string;
const DEVICE_BT_CAPABILITIES: string;
const DEVICE_BT_HW_ADDRESS: string;
const DEVICE_BT_NAME: string;
const DEVICE_CAPABILITIES: string;
const DEVICE_DEVICE_TYPE: string;
const DEVICE_DHCP4_CONFIG: string;
const DEVICE_DHCP6_CONFIG: string;
const DEVICE_DRIVER: string;
const DEVICE_DRIVER_VERSION: string;
const DEVICE_DUMMY_HW_ADDRESS: string;
const DEVICE_ETHERNET_CARRIER: string;
const DEVICE_ETHERNET_HW_ADDRESS: string;
const DEVICE_ETHERNET_PERMANENT_HW_ADDRESS: string;
const DEVICE_ETHERNET_S390_SUBCHANNELS: string;
const DEVICE_ETHERNET_SPEED: string;
const DEVICE_FIRMWARE_MISSING: string;
const DEVICE_FIRMWARE_VERSION: string;
const DEVICE_GENERIC_HW_ADDRESS: string;
const DEVICE_GENERIC_TYPE_DESCRIPTION: string;
const DEVICE_HSR_MULTICAST_SPEC: string;
const DEVICE_HSR_PORT1: string;
const DEVICE_HSR_PORT2: string;
const DEVICE_HSR_PRP: string;
const DEVICE_HSR_SUPERVISION_ADDRESS: string;
const DEVICE_HW_ADDRESS: string;
const DEVICE_INFINIBAND_CARRIER: string;
const DEVICE_INFINIBAND_HW_ADDRESS: string;
const DEVICE_INTERFACE: string;
const DEVICE_INTERFACE_FLAGS: string;
const DEVICE_IP4_CONFIG: string;
const DEVICE_IP4_CONNECTIVITY: string;
const DEVICE_IP6_CONFIG: string;
const DEVICE_IP6_CONNECTIVITY: string;
const DEVICE_IPVLAN_MODE: string;
const DEVICE_IPVLAN_PARENT: string;
const DEVICE_IPVLAN_PRIVATE: string;
const DEVICE_IPVLAN_VEPA: string;
const DEVICE_IP_INTERFACE: string;
const DEVICE_IP_TUNNEL_ENCAPSULATION_LIMIT: string;
const DEVICE_IP_TUNNEL_FLAGS: string;
const DEVICE_IP_TUNNEL_FLOW_LABEL: string;
const DEVICE_IP_TUNNEL_FWMARK: string;
const DEVICE_IP_TUNNEL_INPUT_KEY: string;
const DEVICE_IP_TUNNEL_LOCAL: string;
const DEVICE_IP_TUNNEL_MODE: string;
const DEVICE_IP_TUNNEL_OUTPUT_KEY: string;
const DEVICE_IP_TUNNEL_PARENT: string;
const DEVICE_IP_TUNNEL_PATH_MTU_DISCOVERY: string;
const DEVICE_IP_TUNNEL_REMOTE: string;
const DEVICE_IP_TUNNEL_TOS: string;
const DEVICE_IP_TUNNEL_TTL: string;
const DEVICE_LLDP_NEIGHBORS: string;
const DEVICE_MACSEC_CIPHER_SUITE: string;
const DEVICE_MACSEC_ENCODING_SA: string;
const DEVICE_MACSEC_ENCRYPT: string;
const DEVICE_MACSEC_ES: string;
const DEVICE_MACSEC_HW_ADDRESS: string;
const DEVICE_MACSEC_ICV_LENGTH: string;
const DEVICE_MACSEC_INCLUDE_SCI: string;
const DEVICE_MACSEC_PARENT: string;
const DEVICE_MACSEC_PROTECT: string;
const DEVICE_MACSEC_REPLAY_PROTECT: string;
const DEVICE_MACSEC_SCB: string;
const DEVICE_MACSEC_SCI: string;
const DEVICE_MACSEC_VALIDATION: string;
const DEVICE_MACSEC_WINDOW: string;
const DEVICE_MACVLAN_HW_ADDRESS: string;
const DEVICE_MACVLAN_MODE: string;
const DEVICE_MACVLAN_NO_PROMISC: string;
const DEVICE_MACVLAN_PARENT: string;
const DEVICE_MACVLAN_TAP: string;
const DEVICE_MANAGED: string;
const DEVICE_METERED: string;
const DEVICE_MODEM_APN: string;
const DEVICE_MODEM_CURRENT_CAPABILITIES: string;
const DEVICE_MODEM_DEVICE_ID: string;
const DEVICE_MODEM_MODEM_CAPABILITIES: string;
const DEVICE_MODEM_OPERATOR_CODE: string;
const DEVICE_MTU: string;
const DEVICE_NM_PLUGIN_MISSING: string;
const DEVICE_OLPC_MESH_ACTIVE_CHANNEL: string;
const DEVICE_OLPC_MESH_COMPANION: string;
const DEVICE_OLPC_MESH_HW_ADDRESS: string;
const DEVICE_OVS_BRIDGE_SLAVES: string;
const DEVICE_OVS_PORT_SLAVES: string;
const DEVICE_PATH: string;
const DEVICE_PHYSICAL_PORT_ID: string;
const DEVICE_PORTS: string;
const DEVICE_PRODUCT: string;
const DEVICE_REAL: string;
const DEVICE_STATE: string;
const DEVICE_STATE_REASON: string;
const DEVICE_TEAM_CARRIER: string;
const DEVICE_TEAM_CONFIG: string;
const DEVICE_TEAM_HW_ADDRESS: string;
const DEVICE_TEAM_SLAVES: string;
const DEVICE_TUN_GROUP: string;
const DEVICE_TUN_HW_ADDRESS: string;
const DEVICE_TUN_MODE: string;
const DEVICE_TUN_MULTI_QUEUE: string;
const DEVICE_TUN_NO_PI: string;
const DEVICE_TUN_OWNER: string;
const DEVICE_TUN_VNET_HDR: string;
const DEVICE_UDI: string;
const DEVICE_VENDOR: string;
const DEVICE_VETH_PEER: string;
const DEVICE_VLAN_CARRIER: string;
const DEVICE_VLAN_HW_ADDRESS: string;
const DEVICE_VLAN_PARENT: string;
const DEVICE_VLAN_VLAN_ID: string;
const DEVICE_VRF_TABLE: string;
const DEVICE_VXLAN_AGEING: string;
const DEVICE_VXLAN_CARRIER: string;
const DEVICE_VXLAN_DST_PORT: string;
const DEVICE_VXLAN_GROUP: string;
const DEVICE_VXLAN_HW_ADDRESS: string;
const DEVICE_VXLAN_ID: string;
const DEVICE_VXLAN_L2MISS: string;
const DEVICE_VXLAN_L3MISS: string;
const DEVICE_VXLAN_LEARNING: string;
const DEVICE_VXLAN_LIMIT: string;
const DEVICE_VXLAN_LOCAL: string;
const DEVICE_VXLAN_PARENT: string;
const DEVICE_VXLAN_PROXY: string;
const DEVICE_VXLAN_RSC: string;
const DEVICE_VXLAN_SRC_PORT_MAX: string;
const DEVICE_VXLAN_SRC_PORT_MIN: string;
const DEVICE_VXLAN_TOS: string;
const DEVICE_VXLAN_TTL: string;
const DEVICE_WIFI_ACCESS_POINTS: string;
const DEVICE_WIFI_ACTIVE_ACCESS_POINT: string;
const DEVICE_WIFI_BITRATE: string;
const DEVICE_WIFI_CAPABILITIES: string;
const DEVICE_WIFI_HW_ADDRESS: string;
const DEVICE_WIFI_LAST_SCAN: string;
const DEVICE_WIFI_MODE: string;
const DEVICE_WIFI_P2P_HW_ADDRESS: string;
const DEVICE_WIFI_P2P_PEERS: string;
const DEVICE_WIFI_P2P_WFDIES: string;
const DEVICE_WIFI_PERMANENT_HW_ADDRESS: string;
const DEVICE_WIMAX_ACTIVE_NSP: string;
const DEVICE_WIMAX_BSID: string;
const DEVICE_WIMAX_CENTER_FREQUENCY: string;
const DEVICE_WIMAX_CINR: string;
const DEVICE_WIMAX_HW_ADDRESS: string;
const DEVICE_WIMAX_NSPS: string;
const DEVICE_WIMAX_RSSI: string;
const DEVICE_WIMAX_TX_POWER: string;
const DEVICE_WIREGUARD_FWMARK: string;
const DEVICE_WIREGUARD_LISTEN_PORT: string;
const DEVICE_WIREGUARD_PUBLIC_KEY: string;
const DEVICE_WPAN_HW_ADDRESS: string;
const DHCP_CONFIG_FAMILY: string;
const DHCP_CONFIG_OPTIONS: string;
const ETHTOOL_OPTNAME_CHANNELS_COMBINED: string;
const ETHTOOL_OPTNAME_CHANNELS_OTHER: string;
const ETHTOOL_OPTNAME_CHANNELS_RX: string;
const ETHTOOL_OPTNAME_CHANNELS_TX: string;
const ETHTOOL_OPTNAME_COALESCE_ADAPTIVE_RX: string;
const ETHTOOL_OPTNAME_COALESCE_ADAPTIVE_TX: string;
const ETHTOOL_OPTNAME_COALESCE_PKT_RATE_HIGH: string;
const ETHTOOL_OPTNAME_COALESCE_PKT_RATE_LOW: string;
const ETHTOOL_OPTNAME_COALESCE_RX_FRAMES: string;
const ETHTOOL_OPTNAME_COALESCE_RX_FRAMES_HIGH: string;
const ETHTOOL_OPTNAME_COALESCE_RX_FRAMES_IRQ: string;
const ETHTOOL_OPTNAME_COALESCE_RX_FRAMES_LOW: string;
const ETHTOOL_OPTNAME_COALESCE_RX_USECS: string;
const ETHTOOL_OPTNAME_COALESCE_RX_USECS_HIGH: string;
const ETHTOOL_OPTNAME_COALESCE_RX_USECS_IRQ: string;
const ETHTOOL_OPTNAME_COALESCE_RX_USECS_LOW: string;
const ETHTOOL_OPTNAME_COALESCE_SAMPLE_INTERVAL: string;
const ETHTOOL_OPTNAME_COALESCE_STATS_BLOCK_USECS: string;
const ETHTOOL_OPTNAME_COALESCE_TX_FRAMES: string;
const ETHTOOL_OPTNAME_COALESCE_TX_FRAMES_HIGH: string;
const ETHTOOL_OPTNAME_COALESCE_TX_FRAMES_IRQ: string;
const ETHTOOL_OPTNAME_COALESCE_TX_FRAMES_LOW: string;
const ETHTOOL_OPTNAME_COALESCE_TX_USECS: string;
const ETHTOOL_OPTNAME_COALESCE_TX_USECS_HIGH: string;
const ETHTOOL_OPTNAME_COALESCE_TX_USECS_IRQ: string;
const ETHTOOL_OPTNAME_COALESCE_TX_USECS_LOW: string;
const ETHTOOL_OPTNAME_EEE_ENABLED: string;
const ETHTOOL_OPTNAME_FEATURE_ESP_HW_OFFLOAD: string;
const ETHTOOL_OPTNAME_FEATURE_ESP_TX_CSUM_HW_OFFLOAD: string;
const ETHTOOL_OPTNAME_FEATURE_FCOE_MTU: string;
const ETHTOOL_OPTNAME_FEATURE_GRO: string;
const ETHTOOL_OPTNAME_FEATURE_GSO: string;
const ETHTOOL_OPTNAME_FEATURE_HIGHDMA: string;
const ETHTOOL_OPTNAME_FEATURE_HW_TC_OFFLOAD: string;
const ETHTOOL_OPTNAME_FEATURE_L2_FWD_OFFLOAD: string;
const ETHTOOL_OPTNAME_FEATURE_LOOPBACK: string;
const ETHTOOL_OPTNAME_FEATURE_LRO: string;
const ETHTOOL_OPTNAME_FEATURE_MACSEC_HW_OFFLOAD: string;
const ETHTOOL_OPTNAME_FEATURE_NTUPLE: string;
const ETHTOOL_OPTNAME_FEATURE_RX: string;
const ETHTOOL_OPTNAME_FEATURE_RXHASH: string;
const ETHTOOL_OPTNAME_FEATURE_RXVLAN: string;
const ETHTOOL_OPTNAME_FEATURE_RX_ALL: string;
const ETHTOOL_OPTNAME_FEATURE_RX_FCS: string;
const ETHTOOL_OPTNAME_FEATURE_RX_GRO_HW: string;
const ETHTOOL_OPTNAME_FEATURE_RX_GRO_LIST: string;
const ETHTOOL_OPTNAME_FEATURE_RX_UDP_GRO_FORWARDING: string;
const ETHTOOL_OPTNAME_FEATURE_RX_UDP_TUNNEL_PORT_OFFLOAD: string;
const ETHTOOL_OPTNAME_FEATURE_RX_VLAN_FILTER: string;
const ETHTOOL_OPTNAME_FEATURE_RX_VLAN_STAG_FILTER: string;
const ETHTOOL_OPTNAME_FEATURE_RX_VLAN_STAG_HW_PARSE: string;
const ETHTOOL_OPTNAME_FEATURE_SG: string;
const ETHTOOL_OPTNAME_FEATURE_TLS_HW_RECORD: string;
const ETHTOOL_OPTNAME_FEATURE_TLS_HW_RX_OFFLOAD: string;
const ETHTOOL_OPTNAME_FEATURE_TLS_HW_TX_OFFLOAD: string;
const ETHTOOL_OPTNAME_FEATURE_TSO: string;
const ETHTOOL_OPTNAME_FEATURE_TX: string;
const ETHTOOL_OPTNAME_FEATURE_TXVLAN: string;
const ETHTOOL_OPTNAME_FEATURE_TX_CHECKSUM_FCOE_CRC: string;
const ETHTOOL_OPTNAME_FEATURE_TX_CHECKSUM_IPV4: string;
const ETHTOOL_OPTNAME_FEATURE_TX_CHECKSUM_IPV6: string;
const ETHTOOL_OPTNAME_FEATURE_TX_CHECKSUM_IP_GENERIC: string;
const ETHTOOL_OPTNAME_FEATURE_TX_CHECKSUM_SCTP: string;
const ETHTOOL_OPTNAME_FEATURE_TX_ESP_SEGMENTATION: string;
const ETHTOOL_OPTNAME_FEATURE_TX_FCOE_SEGMENTATION: string;
const ETHTOOL_OPTNAME_FEATURE_TX_GRE_CSUM_SEGMENTATION: string;
const ETHTOOL_OPTNAME_FEATURE_TX_GRE_SEGMENTATION: string;
const ETHTOOL_OPTNAME_FEATURE_TX_GSO_LIST: string;
const ETHTOOL_OPTNAME_FEATURE_TX_GSO_PARTIAL: string;
const ETHTOOL_OPTNAME_FEATURE_TX_GSO_ROBUST: string;
const ETHTOOL_OPTNAME_FEATURE_TX_IPXIP4_SEGMENTATION: string;
const ETHTOOL_OPTNAME_FEATURE_TX_IPXIP6_SEGMENTATION: string;
const ETHTOOL_OPTNAME_FEATURE_TX_NOCACHE_COPY: string;
const ETHTOOL_OPTNAME_FEATURE_TX_SCATTER_GATHER: string;
const ETHTOOL_OPTNAME_FEATURE_TX_SCATTER_GATHER_FRAGLIST: string;
const ETHTOOL_OPTNAME_FEATURE_TX_SCTP_SEGMENTATION: string;
const ETHTOOL_OPTNAME_FEATURE_TX_TCP6_SEGMENTATION: string;
const ETHTOOL_OPTNAME_FEATURE_TX_TCP_ECN_SEGMENTATION: string;
const ETHTOOL_OPTNAME_FEATURE_TX_TCP_MANGLEID_SEGMENTATION: string;
const ETHTOOL_OPTNAME_FEATURE_TX_TCP_SEGMENTATION: string;
const ETHTOOL_OPTNAME_FEATURE_TX_TUNNEL_REMCSUM_SEGMENTATION: string;
const ETHTOOL_OPTNAME_FEATURE_TX_UDP_SEGMENTATION: string;
const ETHTOOL_OPTNAME_FEATURE_TX_UDP_TNL_CSUM_SEGMENTATION: string;
const ETHTOOL_OPTNAME_FEATURE_TX_UDP_TNL_SEGMENTATION: string;
const ETHTOOL_OPTNAME_FEATURE_TX_VLAN_STAG_HW_INSERT: string;
const ETHTOOL_OPTNAME_FEC_MODE: string;
const ETHTOOL_OPTNAME_PAUSE_AUTONEG: string;
const ETHTOOL_OPTNAME_PAUSE_RX: string;
const ETHTOOL_OPTNAME_PAUSE_TX: string;
const ETHTOOL_OPTNAME_RING_RX: string;
const ETHTOOL_OPTNAME_RING_RX_JUMBO: string;
const ETHTOOL_OPTNAME_RING_RX_MINI: string;
const ETHTOOL_OPTNAME_RING_TX: string;
const IP_ADDRESS_ATTRIBUTE_LABEL: string;
const IP_CONFIG_ADDRESSES: string;
const IP_CONFIG_DOMAINS: string;
const IP_CONFIG_FAMILY: string;
const IP_CONFIG_GATEWAY: string;
const IP_CONFIG_NAMESERVERS: string;
const IP_CONFIG_ROUTES: string;
const IP_CONFIG_SEARCHES: string;
const IP_CONFIG_WINS_SERVERS: string;
const IP_ROUTE_ATTRIBUTE_ADVMSS: string;
const IP_ROUTE_ATTRIBUTE_CWND: string;
const IP_ROUTE_ATTRIBUTE_FROM: string;
const IP_ROUTE_ATTRIBUTE_INITCWND: string;
const IP_ROUTE_ATTRIBUTE_INITRWND: string;
const IP_ROUTE_ATTRIBUTE_LOCK_ADVMSS: string;
const IP_ROUTE_ATTRIBUTE_LOCK_CWND: string;
const IP_ROUTE_ATTRIBUTE_LOCK_INITCWND: string;
const IP_ROUTE_ATTRIBUTE_LOCK_INITRWND: string;
const IP_ROUTE_ATTRIBUTE_LOCK_MTU: string;
const IP_ROUTE_ATTRIBUTE_LOCK_WINDOW: string;
const IP_ROUTE_ATTRIBUTE_MTU: string;
const IP_ROUTE_ATTRIBUTE_ONLINK: string;
const IP_ROUTE_ATTRIBUTE_QUICKACK: string;
const IP_ROUTE_ATTRIBUTE_RTO_MIN: string;
const IP_ROUTE_ATTRIBUTE_SCOPE: string;
const IP_ROUTE_ATTRIBUTE_SRC: string;
const IP_ROUTE_ATTRIBUTE_TABLE: string;
const IP_ROUTE_ATTRIBUTE_TOS: string;
const IP_ROUTE_ATTRIBUTE_TYPE: string;
const IP_ROUTE_ATTRIBUTE_WEIGHT: string;
const IP_ROUTE_ATTRIBUTE_WINDOW: string;
const LLDP_ATTR_CHASSIS_ID: string;
const LLDP_ATTR_CHASSIS_ID_TYPE: string;
const LLDP_ATTR_DESTINATION: string;
const LLDP_ATTR_IEEE_802_1_PPVID: string;
const LLDP_ATTR_IEEE_802_1_PPVIDS: string;
const LLDP_ATTR_IEEE_802_1_PPVID_FLAGS: string;
const LLDP_ATTR_IEEE_802_1_PVID: string;
const LLDP_ATTR_IEEE_802_1_VID: string;
const LLDP_ATTR_IEEE_802_1_VLANS: string;
const LLDP_ATTR_IEEE_802_1_VLAN_NAME: string;
const LLDP_ATTR_IEEE_802_3_MAC_PHY_CONF: string;
const LLDP_ATTR_IEEE_802_3_MAX_FRAME_SIZE: string;
const LLDP_ATTR_IEEE_802_3_POWER_VIA_MDI: string;
const LLDP_ATTR_MANAGEMENT_ADDRESSES: string;
const LLDP_ATTR_MUD_URL: string;
const LLDP_ATTR_PORT_DESCRIPTION: string;
const LLDP_ATTR_PORT_ID: string;
const LLDP_ATTR_PORT_ID_TYPE: string;
const LLDP_ATTR_RAW: string;
const LLDP_ATTR_SYSTEM_CAPABILITIES: string;
const LLDP_ATTR_SYSTEM_DESCRIPTION: string;
const LLDP_ATTR_SYSTEM_NAME: string;
const LLDP_DEST_NEAREST_BRIDGE: string;
const LLDP_DEST_NEAREST_CUSTOMER_BRIDGE: string;
const LLDP_DEST_NEAREST_NON_TPMR_BRIDGE: string;
/**
* Evaluates to the major version number of NetworkManager which this source
* is compiled against.
*/
const MAJOR_VERSION: number;
/**
* Evaluates to the micro version number of NetworkManager which this source
* compiled against.
*/
const MICRO_VERSION: number;
/**
* Evaluates to the minor version number of NetworkManager which this source
* is compiled against.
*/
const MINOR_VERSION: number;
const OBJECT_CLIENT: string;
const OBJECT_PATH: string;
const REMOTE_CONNECTION_DBUS_CONNECTION: string;
const REMOTE_CONNECTION_FILENAME: string;
const REMOTE_CONNECTION_FLAGS: string;
const REMOTE_CONNECTION_PATH: string;
const REMOTE_CONNECTION_UNSAVED: string;
const REMOTE_CONNECTION_VERSION_ID: string;
const REMOTE_CONNECTION_VISIBLE: string;
const SECRET_AGENT_OLD_AUTO_REGISTER: string;
const SECRET_AGENT_OLD_CAPABILITIES: string;
const SECRET_AGENT_OLD_DBUS_CONNECTION: string;
const SECRET_AGENT_OLD_IDENTIFIER: string;
const SECRET_AGENT_OLD_REGISTERED: string;
const SECRET_TAG_DYNAMIC_CHALLENGE: string;
const SECRET_TAG_DYNAMIC_CHALLENGE_ECHO: string;
const SECRET_TAG_VPN_MSG: string;
const SETTING_6LOWPAN_PARENT: string;
const SETTING_6LOWPAN_SETTING_NAME: string;
const SETTING_802_1X_ALTSUBJECT_MATCHES: string;
const SETTING_802_1X_ANONYMOUS_IDENTITY: string;
const SETTING_802_1X_AUTH_TIMEOUT: string;
const SETTING_802_1X_CA_CERT: string;
const SETTING_802_1X_CA_CERT_PASSWORD: string;
const SETTING_802_1X_CA_CERT_PASSWORD_FLAGS: string;
const SETTING_802_1X_CA_PATH: string;
const SETTING_802_1X_CERT_SCHEME_PREFIX_PATH: string;
const SETTING_802_1X_CERT_SCHEME_PREFIX_PKCS11: string;
const SETTING_802_1X_CLIENT_CERT: string;
const SETTING_802_1X_CLIENT_CERT_PASSWORD: string;
const SETTING_802_1X_CLIENT_CERT_PASSWORD_FLAGS: string;
const SETTING_802_1X_DOMAIN_MATCH: string;
const SETTING_802_1X_DOMAIN_SUFFIX_MATCH: string;
const SETTING_802_1X_EAP: string;
const SETTING_802_1X_IDENTITY: string;
const SETTING_802_1X_OPENSSL_CIPHERS: string;
const SETTING_802_1X_OPTIONAL: string;
const SETTING_802_1X_PAC_FILE: string;
const SETTING_802_1X_PASSWORD: string;
const SETTING_802_1X_PASSWORD_FLAGS: string;
const SETTING_802_1X_PASSWORD_RAW: string;
const SETTING_802_1X_PASSWORD_RAW_FLAGS: string;
const SETTING_802_1X_PHASE1_AUTH_FLAGS: string;
const SETTING_802_1X_PHASE1_FAST_PROVISIONING: string;
const SETTING_802_1X_PHASE1_PEAPLABEL: string;
const SETTING_802_1X_PHASE1_PEAPVER: string;
const SETTING_802_1X_PHASE2_ALTSUBJECT_MATCHES: string;
const SETTING_802_1X_PHASE2_AUTH: string;
const SETTING_802_1X_PHASE2_AUTHEAP: string;
const SETTING_802_1X_PHASE2_CA_CERT: string;
const SETTING_802_1X_PHASE2_CA_CERT_PASSWORD: string;
const SETTING_802_1X_PHASE2_CA_CERT_PASSWORD_FLAGS: string;
const SETTING_802_1X_PHASE2_CA_PATH: string;
const SETTING_802_1X_PHASE2_CLIENT_CERT: string;
const SETTING_802_1X_PHASE2_CLIENT_CERT_PASSWORD: string;
const SETTING_802_1X_PHASE2_CLIENT_CERT_PASSWORD_FLAGS: string;
const SETTING_802_1X_PHASE2_DOMAIN_MATCH: string;
const SETTING_802_1X_PHASE2_DOMAIN_SUFFIX_MATCH: string;
const SETTING_802_1X_PHASE2_PRIVATE_KEY: string;
const SETTING_802_1X_PHASE2_PRIVATE_KEY_PASSWORD: string;
const SETTING_802_1X_PHASE2_PRIVATE_KEY_PASSWORD_FLAGS: string;
const SETTING_802_1X_PHASE2_SUBJECT_MATCH: string;
const SETTING_802_1X_PIN: string;
const SETTING_802_1X_PIN_FLAGS: string;
const SETTING_802_1X_PRIVATE_KEY: string;
const SETTING_802_1X_PRIVATE_KEY_PASSWORD: string;
const SETTING_802_1X_PRIVATE_KEY_PASSWORD_FLAGS: string;
const SETTING_802_1X_SETTING_NAME: string;
const SETTING_802_1X_SUBJECT_MATCH: string;
const SETTING_802_1X_SYSTEM_CA_CERTS: string;
const SETTING_ADSL_ENCAPSULATION: string;
const SETTING_ADSL_ENCAPSULATION_LLC: string;
const SETTING_ADSL_ENCAPSULATION_VCMUX: string;
const SETTING_ADSL_PASSWORD: string;
const SETTING_ADSL_PASSWORD_FLAGS: string;
const SETTING_ADSL_PROTOCOL: string;
const SETTING_ADSL_PROTOCOL_IPOATM: string;
const SETTING_ADSL_PROTOCOL_PPPOA: string;
const SETTING_ADSL_PROTOCOL_PPPOE: string;
const SETTING_ADSL_SETTING_NAME: string;
const SETTING_ADSL_USERNAME: string;
const SETTING_ADSL_VCI: string;
const SETTING_ADSL_VPI: string;
const SETTING_BLUETOOTH_BDADDR: string;
const SETTING_BLUETOOTH_SETTING_NAME: string;
const SETTING_BLUETOOTH_TYPE: string;
/**
* Connection type describing a connection to devices that support the Bluetooth
* DUN profile.
*/
const SETTING_BLUETOOTH_TYPE_DUN: string;
/**
* Connection type describing a Bluetooth NAP (Network Access Point),
* which accepts PANU clients.
*/
const SETTING_BLUETOOTH_TYPE_NAP: string;
/**
* Connection type describing PANU connection to a Bluetooth NAP (Network
* Access Point).
*/
const SETTING_BLUETOOTH_TYPE_PANU: string;
const SETTING_BOND_OPTIONS: string;
const SETTING_BOND_OPTION_ACTIVE_SLAVE: string;
const SETTING_BOND_OPTION_AD_ACTOR_SYSTEM: string;
const SETTING_BOND_OPTION_AD_ACTOR_SYS_PRIO: string;
const SETTING_BOND_OPTION_AD_SELECT: string;
const SETTING_BOND_OPTION_AD_USER_PORT_KEY: string;
const SETTING_BOND_OPTION_ALL_SLAVES_ACTIVE: string;
const SETTING_BOND_OPTION_ARP_ALL_TARGETS: string;
const SETTING_BOND_OPTION_ARP_INTERVAL: string;
const SETTING_BOND_OPTION_ARP_IP_TARGET: string;
const SETTING_BOND_OPTION_ARP_MISSED_MAX: string;
const SETTING_BOND_OPTION_ARP_VALIDATE: string;
const SETTING_BOND_OPTION_BALANCE_SLB: string;
const SETTING_BOND_OPTION_DOWNDELAY: string;
const SETTING_BOND_OPTION_FAIL_OVER_MAC: string;
const SETTING_BOND_OPTION_LACP_ACTIVE: string;
const SETTING_BOND_OPTION_LACP_RATE: string;
const SETTING_BOND_OPTION_LP_INTERVAL: string;
const SETTING_BOND_OPTION_MIIMON: string;
const SETTING_BOND_OPTION_MIN_LINKS: string;
const SETTING_BOND_OPTION_MODE: string;
const SETTING_BOND_OPTION_NS_IP6_TARGET: string;
const SETTING_BOND_OPTION_NUM_GRAT_ARP: string;
const SETTING_BOND_OPTION_NUM_UNSOL_NA: string;
const SETTING_BOND_OPTION_PACKETS_PER_SLAVE: string;
const SETTING_BOND_OPTION_PEER_NOTIF_DELAY: string;
const SETTING_BOND_OPTION_PRIMARY: string;
const SETTING_BOND_OPTION_PRIMARY_RESELECT: string;
const SETTING_BOND_OPTION_RESEND_IGMP: string;
const SETTING_BOND_OPTION_TLB_DYNAMIC_LB: string;
const SETTING_BOND_OPTION_UPDELAY: string;
const SETTING_BOND_OPTION_USE_CARRIER: string;
const SETTING_BOND_OPTION_XMIT_HASH_POLICY: string;
const SETTING_BOND_PORT_PRIO: string;
const SETTING_BOND_PORT_QUEUE_ID: string;
const SETTING_BOND_PORT_SETTING_NAME: string;
const SETTING_BOND_SETTING_NAME: string;
const SETTING_BRIDGE_AGEING_TIME: string;
const SETTING_BRIDGE_FORWARD_DELAY: string;
const SETTING_BRIDGE_GROUP_ADDRESS: string;
const SETTING_BRIDGE_GROUP_FORWARD_MASK: string;
const SETTING_BRIDGE_HELLO_TIME: string;
const SETTING_BRIDGE_MAC_ADDRESS: string;
const SETTING_BRIDGE_MAX_AGE: string;
const SETTING_BRIDGE_MULTICAST_HASH_MAX: string;
const SETTING_BRIDGE_MULTICAST_LAST_MEMBER_COUNT: string;
const SETTING_BRIDGE_MULTICAST_LAST_MEMBER_INTERVAL: string;
const SETTING_BRIDGE_MULTICAST_MEMBERSHIP_INTERVAL: string;
const SETTING_BRIDGE_MULTICAST_QUERIER: string;
const SETTING_BRIDGE_MULTICAST_QUERIER_INTERVAL: string;
const SETTING_BRIDGE_MULTICAST_QUERY_INTERVAL: string;
const SETTING_BRIDGE_MULTICAST_QUERY_RESPONSE_INTERVAL: string;
const SETTING_BRIDGE_MULTICAST_QUERY_USE_IFADDR: string;
const SETTING_BRIDGE_MULTICAST_ROUTER: string;
const SETTING_BRIDGE_MULTICAST_SNOOPING: string;
const SETTING_BRIDGE_MULTICAST_STARTUP_QUERY_COUNT: string;
const SETTING_BRIDGE_MULTICAST_STARTUP_QUERY_INTERVAL: string;
const SETTING_BRIDGE_PORT_HAIRPIN_MODE: string;
const SETTING_BRIDGE_PORT_PATH_COST: string;
const SETTING_BRIDGE_PORT_PRIORITY: string;
const SETTING_BRIDGE_PORT_SETTING_NAME: string;
const SETTING_BRIDGE_PORT_VLANS: string;
const SETTING_BRIDGE_PRIORITY: string;
const SETTING_BRIDGE_SETTING_NAME: string;
const SETTING_BRIDGE_STP: string;
const SETTING_BRIDGE_VLANS: string;
const SETTING_BRIDGE_VLAN_DEFAULT_PVID: string;
const SETTING_BRIDGE_VLAN_FILTERING: string;
const SETTING_BRIDGE_VLAN_PROTOCOL: string;
const SETTING_BRIDGE_VLAN_STATS_ENABLED: string;
const SETTING_CDMA_MTU: string;
const SETTING_CDMA_NUMBER: string;
const SETTING_CDMA_PASSWORD: string;
const SETTING_CDMA_PASSWORD_FLAGS: string;
const SETTING_CDMA_SETTING_NAME: string;
const SETTING_CDMA_USERNAME: string;
const SETTING_CONNECTION_AUTH_RETRIES: string;
const SETTING_CONNECTION_AUTOCONNECT: string;
const SETTING_CONNECTION_AUTOCONNECT_PORTS: string;
const SETTING_CONNECTION_AUTOCONNECT_PRIORITY: string;
const SETTING_CONNECTION_AUTOCONNECT_PRIORITY_DEFAULT: number;
const SETTING_CONNECTION_AUTOCONNECT_PRIORITY_MAX: number;
const SETTING_CONNECTION_AUTOCONNECT_PRIORITY_MIN: number;
const SETTING_CONNECTION_AUTOCONNECT_RETRIES: string;
const SETTING_CONNECTION_AUTOCONNECT_SLAVES: string;
const SETTING_CONNECTION_CONTROLLER: string;
const SETTING_CONNECTION_DNS_OVER_TLS: string;
const SETTING_CONNECTION_DOWN_ON_POWEROFF: string;
const SETTING_CONNECTION_GATEWAY_PING_TIMEOUT: string;
const SETTING_CONNECTION_ID: string;
const SETTING_CONNECTION_INTERFACE_NAME: string;
const SETTING_CONNECTION_IP_PING_ADDRESSES: string;
const SETTING_CONNECTION_IP_PING_ADDRESSES_REQUIRE_ALL: string;
const SETTING_CONNECTION_IP_PING_TIMEOUT: string;
const SETTING_CONNECTION_LLDP: string;
const SETTING_CONNECTION_LLMNR: string;
const SETTING_CONNECTION_MASTER: string;
const SETTING_CONNECTION_MDNS: string;
const SETTING_CONNECTION_METERED: string;
const SETTING_CONNECTION_MPTCP_FLAGS: string;
const SETTING_CONNECTION_MUD_URL: string;
const SETTING_CONNECTION_MULTI_CONNECT: string;
const SETTING_CONNECTION_PERMISSIONS: string;
const SETTING_CONNECTION_PORT_TYPE: string;
const SETTING_CONNECTION_READ_ONLY: string;
const SETTING_CONNECTION_SECONDARIES: string;
const SETTING_CONNECTION_SETTING_NAME: string;
const SETTING_CONNECTION_SLAVE_TYPE: string;
const SETTING_CONNECTION_STABLE_ID: string;
const SETTING_CONNECTION_TIMESTAMP: string;
const SETTING_CONNECTION_TYPE: string;
const SETTING_CONNECTION_UUID: string;
const SETTING_CONNECTION_WAIT_ACTIVATION_DELAY: string;
const SETTING_CONNECTION_WAIT_DEVICE_TIMEOUT: string;
const SETTING_CONNECTION_ZONE: string;
const SETTING_DCB_APP_FCOE_FLAGS: string;
const SETTING_DCB_APP_FCOE_MODE: string;
const SETTING_DCB_APP_FCOE_PRIORITY: string;
const SETTING_DCB_APP_FIP_FLAGS: string;
const SETTING_DCB_APP_FIP_PRIORITY: string;
const SETTING_DCB_APP_ISCSI_FLAGS: string;
const SETTING_DCB_APP_ISCSI_PRIORITY: string;
/**
* Indicates that the FCoE controller should use "fabric" mode (default)
*/
const SETTING_DCB_FCOE_MODE_FABRIC: string;
/**
* Indicates that the FCoE controller should use "VN2VN" mode.
*/
const SETTING_DCB_FCOE_MODE_VN2VN: string;
const SETTING_DCB_PRIORITY_BANDWIDTH: string;
const SETTING_DCB_PRIORITY_FLOW_CONTROL: string;
const SETTING_DCB_PRIORITY_FLOW_CONTROL_FLAGS: string;
const SETTING_DCB_PRIORITY_GROUP_BANDWIDTH: string;
const SETTING_DCB_PRIORITY_GROUP_FLAGS: string;
const SETTING_DCB_PRIORITY_GROUP_ID: string;
const SETTING_DCB_PRIORITY_STRICT_BANDWIDTH: string;
const SETTING_DCB_PRIORITY_TRAFFIC_CLASS: string;
const SETTING_DCB_SETTING_NAME: string;
const SETTING_DNS_OPTION_ATTEMPTS: string;
const SETTING_DNS_OPTION_DEBUG: string;
const SETTING_DNS_OPTION_EDNS0: string;
const SETTING_DNS_OPTION_INET6: string;
const SETTING_DNS_OPTION_INTERNAL_NO_ADD_EDNS0: string;
const SETTING_DNS_OPTION_INTERNAL_NO_ADD_TRUST_AD: string;
const SETTING_DNS_OPTION_IP6_BYTESTRING: string;
const SETTING_DNS_OPTION_IP6_DOTINT: string;
const SETTING_DNS_OPTION_NDOTS: string;
const SETTING_DNS_OPTION_NO_AAAA: string;
const SETTING_DNS_OPTION_NO_CHECK_NAMES: string;
const SETTING_DNS_OPTION_NO_IP6_DOTINT: string;
const SETTING_DNS_OPTION_NO_RELOAD: string;
const SETTING_DNS_OPTION_NO_TLD_QUERY: string;
const SETTING_DNS_OPTION_ROTATE: string;
const SETTING_DNS_OPTION_SINGLE_REQUEST: string;
const SETTING_DNS_OPTION_SINGLE_REQUEST_REOPEN: string;
const SETTING_DNS_OPTION_TIMEOUT: string;
const SETTING_DNS_OPTION_TRUST_AD: string;
const SETTING_DNS_OPTION_USE_VC: string;
const SETTING_DUMMY_SETTING_NAME: string;
const SETTING_ETHTOOL_SETTING_NAME: string;
const SETTING_GENERIC_DEVICE_HANDLER: string;
const SETTING_GENERIC_SETTING_NAME: string;
const SETTING_GSM_APN: string;
const SETTING_GSM_AUTO_CONFIG: string;
const SETTING_GSM_DEVICE_ID: string;
const SETTING_GSM_HOME_ONLY: string;
const SETTING_GSM_INITIAL_EPS_BEARER_APN: string;
const SETTING_GSM_INITIAL_EPS_BEARER_CONFIGURE: string;
const SETTING_GSM_INITIAL_EPS_BEARER_NOAUTH: string;
const SETTING_GSM_INITIAL_EPS_BEARER_PASSWORD: string;
const SETTING_GSM_INITIAL_EPS_BEARER_PASSWORD_FLAGS: string;
const SETTING_GSM_INITIAL_EPS_BEARER_REFUSE_CHAP: string;
const SETTING_GSM_INITIAL_EPS_BEARER_REFUSE_EAP: string;
const SETTING_GSM_INITIAL_EPS_BEARER_REFUSE_MSCHAP: string;
const SETTING_GSM_INITIAL_EPS_BEARER_REFUSE_MSCHAPV2: string;
const SETTING_GSM_INITIAL_EPS_BEARER_REFUSE_PAP: string;
const SETTING_GSM_INITIAL_EPS_BEARER_USERNAME: string;
const SETTING_GSM_MTU: string;
const SETTING_GSM_NETWORK_ID: string;
const SETTING_GSM_NUMBER: string;
const SETTING_GSM_PASSWORD: string;
const SETTING_GSM_PASSWORD_FLAGS: string;
const SETTING_GSM_PIN: string;
const SETTING_GSM_PIN_FLAGS: string;
const SETTING_GSM_SETTING_NAME: string;
const SETTING_GSM_SIM_ID: string;
const SETTING_GSM_SIM_OPERATOR_ID: string;
const SETTING_GSM_USERNAME: string;
const SETTING_HOSTNAME_FROM_DHCP: string;
const SETTING_HOSTNAME_FROM_DNS_LOOKUP: string;
const SETTING_HOSTNAME_ONLY_FROM_DEFAULT: string;
const SETTING_HOSTNAME_PRIORITY: string;
const SETTING_HOSTNAME_SETTING_NAME: string;
const SETTING_HSR_MULTICAST_SPEC: string;
const SETTING_HSR_PORT1: string;
const SETTING_HSR_PORT2: string;
const SETTING_HSR_PRP: string;
const SETTING_HSR_SETTING_NAME: string;
const SETTING_INFINIBAND_MAC_ADDRESS: string;
const SETTING_INFINIBAND_MTU: string;
const SETTING_INFINIBAND_PARENT: string;
const SETTING_INFINIBAND_P_KEY: string;
const SETTING_INFINIBAND_SETTING_NAME: string;
const SETTING_INFINIBAND_TRANSPORT_MODE: string;
const SETTING_IP4_CONFIG_DHCP_CLIENT_ID: string;
const SETTING_IP4_CONFIG_DHCP_FQDN: string;
const SETTING_IP4_CONFIG_DHCP_IPV6_ONLY_PREFERRED: string;
const SETTING_IP4_CONFIG_DHCP_VENDOR_CLASS_IDENTIFIER: string;
const SETTING_IP4_CONFIG_LINK_LOCAL: string;
/**
* IPv4 configuration should be automatically determined via a method appropriate
* for the hardware interface, ie DHCP or PPP or some other device-specific
* manner.
*/
const SETTING_IP4_CONFIG_METHOD_AUTO: string;
/**
* This connection does not use or require IPv4 address and it should be disabled.
*/
const SETTING_IP4_CONFIG_METHOD_DISABLED: string;
/**
* IPv4 configuration should be automatically configured for link-local-only
* operation.
*/
const SETTING_IP4_CONFIG_METHOD_LINK_LOCAL: string;
/**
* All necessary IPv4 configuration (addresses, prefix, DNS, etc) is specified
* in the setting's properties.
*/
const SETTING_IP4_CONFIG_METHOD_MANUAL: string;
/**
* This connection specifies configuration that allows other computers to
* connect through it to the default network (usually the Internet). The
* connection's interface will be assigned a private address, and a DHCP server,
* caching DNS server, and Network Address Translation (NAT) functionality will
* be started on this connection's interface to allow other devices to connect
* through that interface to the default network.
*/
const SETTING_IP4_CONFIG_METHOD_SHARED: string;
const SETTING_IP4_CONFIG_SETTING_NAME: string;
const SETTING_IP6_CONFIG_ADDR_GEN_MODE: string;
const SETTING_IP6_CONFIG_DHCP_DUID: string;
const SETTING_IP6_CONFIG_DHCP_PD_HINT: string;
const SETTING_IP6_CONFIG_IP6_PRIVACY: string;
/**
* IPv6 configuration should be automatically determined via a method appropriate
* for the hardware interface, ie router advertisements, DHCP, or PPP or some
* other device-specific manner.
*/
const SETTING_IP6_CONFIG_METHOD_AUTO: string;
/**
* IPv6 configuration should be automatically determined via DHCPv6 only and
* router advertisements should be ignored.
*/
const SETTING_IP6_CONFIG_METHOD_DHCP: string;
/**
* IPv6 is disabled for the connection.
*/
const SETTING_IP6_CONFIG_METHOD_DISABLED: string;
/**
* IPv6 is not required or is handled by some other mechanism, and NetworkManager
* should not configure IPv6 for this connection.
*/
const SETTING_IP6_CONFIG_METHOD_IGNORE: string;
/**
* IPv6 configuration should be automatically configured for link-local-only
* operation.
*/
const SETTING_IP6_CONFIG_METHOD_LINK_LOCAL: string;
/**
* All necessary IPv6 configuration (addresses, prefix, DNS, etc) is specified
* in the setting's properties.
*/
const SETTING_IP6_CONFIG_METHOD_MANUAL: string;
/**
* This connection specifies configuration that allows other computers to
* connect through it to the default network (usually the Internet). The
* connection's interface will be assigned a private address, and router
* advertisements, a caching DNS server, and Network Address Translation (NAT)
* functionality will be started on this connection's interface to allow other
* devices to connect through that interface to the default network. (not yet
* supported for IPv6)
*/
const SETTING_IP6_CONFIG_METHOD_SHARED: string;
const SETTING_IP6_CONFIG_MTU: string;
const SETTING_IP6_CONFIG_RA_TIMEOUT: string;
const SETTING_IP6_CONFIG_SETTING_NAME: string;
const SETTING_IP6_CONFIG_TEMP_PREFERRED_LIFETIME: string;
const SETTING_IP6_CONFIG_TEMP_VALID_LIFETIME: string;
const SETTING_IP6_CONFIG_TOKEN: string;
const SETTING_IPVLAN_MODE: string;
const SETTING_IPVLAN_PARENT: string;
const SETTING_IPVLAN_PRIVATE: string;
const SETTING_IPVLAN_SETTING_NAME: string;
const SETTING_IPVLAN_VEPA: string;
const SETTING_IP_CONFIG_ADDRESSES: string;
const SETTING_IP_CONFIG_AUTO_ROUTE_EXT_GW: string;
const SETTING_IP_CONFIG_DAD_TIMEOUT: string;
const SETTING_IP_CONFIG_DAD_TIMEOUT_MAX: number;
const SETTING_IP_CONFIG_DHCP_DSCP: string;
const SETTING_IP_CONFIG_DHCP_HOSTNAME: string;
const SETTING_IP_CONFIG_DHCP_HOSTNAME_FLAGS: string;
const SETTING_IP_CONFIG_DHCP_IAID: string;
const SETTING_IP_CONFIG_DHCP_REJECT_SERVERS: string;
const SETTING_IP_CONFIG_DHCP_SEND_HOSTNAME: string;
const SETTING_IP_CONFIG_DHCP_SEND_HOSTNAME_V2: string;
const SETTING_IP_CONFIG_DHCP_SEND_RELEASE: string;
const SETTING_IP_CONFIG_DHCP_TIMEOUT: string;
const SETTING_IP_CONFIG_DNS: string;
const SETTING_IP_CONFIG_DNS_OPTIONS: string;
const SETTING_IP_CONFIG_DNS_PRIORITY: string;
const SETTING_IP_CONFIG_DNS_SEARCH: string;
const SETTING_IP_CONFIG_GATEWAY: string;
const SETTING_IP_CONFIG_IGNORE_AUTO_DNS: string;
const SETTING_IP_CONFIG_IGNORE_AUTO_ROUTES: string;
const SETTING_IP_CONFIG_MAY_FAIL: string;
const SETTING_IP_CONFIG_METHOD: string;
const SETTING_IP_CONFIG_NEVER_DEFAULT: string;
const SETTING_IP_CONFIG_REPLACE_LOCAL_RULE: string;
const SETTING_IP_CONFIG_REQUIRED_TIMEOUT: string;
const SETTING_IP_CONFIG_ROUTED_DNS: string;
const SETTING_IP_CONFIG_ROUTES: string;
const SETTING_IP_CONFIG_ROUTE_METRIC: string;
const SETTING_IP_CONFIG_ROUTE_TABLE: string;
const SETTING_IP_CONFIG_ROUTING_RULES: string;
const SETTING_IP_CONFIG_SHARED_DHCP_LEASE_TIME: string;
const SETTING_IP_CONFIG_SHARED_DHCP_RANGE: string;
const SETTING_IP_TUNNEL_ENCAPSULATION_LIMIT: string;
const SETTING_IP_TUNNEL_FLAGS: string;
const SETTING_IP_TUNNEL_FLOW_LABEL: string;
const SETTING_IP_TUNNEL_FWMARK: string;
const SETTING_IP_TUNNEL_INPUT_KEY: string;
const SETTING_IP_TUNNEL_LOCAL: string;
const SETTING_IP_TUNNEL_MODE: string;
const SETTING_IP_TUNNEL_MTU: string;
const SETTING_IP_TUNNEL_OUTPUT_KEY: string;
const SETTING_IP_TUNNEL_PARENT: string;
const SETTING_IP_TUNNEL_PATH_MTU_DISCOVERY: string;
const SETTING_IP_TUNNEL_REMOTE: string;
const SETTING_IP_TUNNEL_SETTING_NAME: string;
const SETTING_IP_TUNNEL_TOS: string;
const SETTING_IP_TUNNEL_TTL: string;
const SETTING_LINK_GRO_MAX_SIZE: string;
const SETTING_LINK_GSO_MAX_SEGMENTS: string;
const SETTING_LINK_GSO_MAX_SIZE: string;
const SETTING_LINK_SETTING_NAME: string;
const SETTING_LINK_TX_QUEUE_LENGTH: string;
const SETTING_LOOPBACK_MTU: string;
const SETTING_LOOPBACK_SETTING_NAME: string;
const SETTING_MACSEC_ENCRYPT: string;
const SETTING_MACSEC_MKA_CAK: string;
const SETTING_MACSEC_MKA_CAK_FLAGS: string;
const SETTING_MACSEC_MKA_CAK_LENGTH: number;
const SETTING_MACSEC_MKA_CKN: string;
const SETTING_MACSEC_MKA_CKN_LENGTH: number;
const SETTING_MACSEC_MODE: string;
const SETTING_MACSEC_OFFLOAD: string;
const SETTING_MACSEC_PARENT: string;
const SETTING_MACSEC_PORT: string;
const SETTING_MACSEC_SEND_SCI: string;
const SETTING_MACSEC_SETTING_NAME: string;
const SETTING_MACSEC_VALIDATION: string;
const SETTING_MACVLAN_MODE: string;
const SETTING_MACVLAN_PARENT: string;
const SETTING_MACVLAN_PROMISCUOUS: string;
const SETTING_MACVLAN_SETTING_NAME: string;
const SETTING_MACVLAN_TAP: string;
const SETTING_MATCH_DRIVER: string;
const SETTING_MATCH_INTERFACE_NAME: string;
const SETTING_MATCH_KERNEL_COMMAND_LINE: string;
const SETTING_MATCH_PATH: string;
const SETTING_MATCH_SETTING_NAME: string;
const SETTING_NAME: string;
const SETTING_OLPC_MESH_CHANNEL: string;
const SETTING_OLPC_MESH_DHCP_ANYCAST_ADDRESS: string;
const SETTING_OLPC_MESH_SETTING_NAME: string;
const SETTING_OLPC_MESH_SSID: string;
const SETTING_OVS_BRIDGE_DATAPATH_TYPE: string;
const SETTING_OVS_BRIDGE_FAIL_MODE: string;
const SETTING_OVS_BRIDGE_MCAST_SNOOPING_ENABLE: string;
const SETTING_OVS_BRIDGE_RSTP_ENABLE: string;
const SETTING_OVS_BRIDGE_SETTING_NAME: string;
const SETTING_OVS_BRIDGE_STP_ENABLE: string;
const SETTING_OVS_DPDK_DEVARGS: string;
const SETTING_OVS_DPDK_N_RXQ: string;
const SETTING_OVS_DPDK_N_RXQ_DESC: string;
const SETTING_OVS_DPDK_N_TXQ_DESC: string;
const SETTING_OVS_DPDK_SETTING_NAME: string;
const SETTING_OVS_EXTERNAL_IDS_DATA: string;
const SETTING_OVS_EXTERNAL_IDS_SETTING_NAME: string;
const SETTING_OVS_INTERFACE_OFPORT_REQUEST: string;
const SETTING_OVS_INTERFACE_SETTING_NAME: string;
const SETTING_OVS_INTERFACE_TYPE: string;
const SETTING_OVS_OTHER_CONFIG_DATA: string;
const SETTING_OVS_OTHER_CONFIG_SETTING_NAME: string;
const SETTING_OVS_PATCH_PEER: string;
const SETTING_OVS_PATCH_SETTING_NAME: string;
const SETTING_OVS_PORT_BOND_DOWNDELAY: string;
const SETTING_OVS_PORT_BOND_MODE: string;
const SETTING_OVS_PORT_BOND_UPDELAY: string;
const SETTING_OVS_PORT_LACP: string;
const SETTING_OVS_PORT_SETTING_NAME: string;
const SETTING_OVS_PORT_TAG: string;
const SETTING_OVS_PORT_TRUNKS: string;
const SETTING_OVS_PORT_VLAN_MODE: string;
const SETTING_PARAM_FUZZY_IGNORE: number;
const SETTING_PARAM_REQUIRED: number;
const SETTING_PARAM_SECRET: number;
const SETTING_PPPOE_PARENT: string;
const SETTING_PPPOE_PASSWORD: string;
const SETTING_PPPOE_PASSWORD_FLAGS: string;
const SETTING_PPPOE_SERVICE: string;
const SETTING_PPPOE_SETTING_NAME: string;
const SETTING_PPPOE_USERNAME: string;
const SETTING_PPP_BAUD: string;
const SETTING_PPP_CRTSCTS: string;
const SETTING_PPP_LCP_ECHO_FAILURE: string;
const SETTING_PPP_LCP_ECHO_INTERVAL: string;
const SETTING_PPP_MPPE_STATEFUL: string;
const SETTING_PPP_MRU: string;
const SETTING_PPP_MTU: string;
const SETTING_PPP_NOAUTH: string;
const SETTING_PPP_NOBSDCOMP: string;
const SETTING_PPP_NODEFLATE: string;
const SETTING_PPP_NO_VJ_COMP: string;
const SETTING_PPP_REFUSE_CHAP: string;
const SETTING_PPP_REFUSE_EAP: string;
const SETTING_PPP_REFUSE_MSCHAP: string;
const SETTING_PPP_REFUSE_MSCHAPV2: string;
const SETTING_PPP_REFUSE_PAP: string;
const SETTING_PPP_REQUIRE_MPPE: string;
const SETTING_PPP_REQUIRE_MPPE_128: string;
const SETTING_PPP_SETTING_NAME: string;
const SETTING_PROXY_BROWSER_ONLY: string;
const SETTING_PROXY_METHOD: string;
const SETTING_PROXY_PAC_SCRIPT: string;
const SETTING_PROXY_PAC_URL: string;
const SETTING_PROXY_SETTING_NAME: string;
const SETTING_SERIAL_BAUD: string;
const SETTING_SERIAL_BITS: string;
const SETTING_SERIAL_PARITY: string;
const SETTING_SERIAL_SEND_DELAY: string;
const SETTING_SERIAL_SETTING_NAME: string;
const SETTING_SERIAL_STOPBITS: string;
const SETTING_SRIOV_AUTOPROBE_DRIVERS: string;
const SETTING_SRIOV_ESWITCH_ENCAP_MODE: string;
const SETTING_SRIOV_ESWITCH_INLINE_MODE: string;
const SETTING_SRIOV_ESWITCH_MODE: string;
const SETTING_SRIOV_SETTING_NAME: string;
const SETTING_SRIOV_TOTAL_VFS: string;
const SETTING_SRIOV_VFS: string;
const SETTING_TC_CONFIG_QDISCS: string;
const SETTING_TC_CONFIG_SETTING_NAME: string;
const SETTING_TC_CONFIG_TFILTERS: string;
const SETTING_TEAM_CONFIG: string;
const SETTING_TEAM_LINK_WATCHERS: string;
const SETTING_TEAM_MCAST_REJOIN_COUNT: string;
const SETTING_TEAM_MCAST_REJOIN_INTERVAL: string;
const SETTING_TEAM_NOTIFY_MCAST_COUNT_ACTIVEBACKUP_DEFAULT: number;
const SETTING_TEAM_NOTIFY_PEERS_COUNT: string;
const SETTING_TEAM_NOTIFY_PEERS_COUNT_ACTIVEBACKUP_DEFAULT: number;
const SETTING_TEAM_NOTIFY_PEERS_INTERVAL: string;
const SETTING_TEAM_PORT_CONFIG: string;
const SETTING_TEAM_PORT_LACP_KEY: string;
const SETTING_TEAM_PORT_LACP_PRIO: string;
const SETTING_TEAM_PORT_LACP_PRIO_DEFAULT: number;
const SETTING_TEAM_PORT_LINK_WATCHERS: string;
const SETTING_TEAM_PORT_PRIO: string;
const SETTING_TEAM_PORT_QUEUE_ID: string;
const SETTING_TEAM_PORT_QUEUE_ID_DEFAULT: number;
const SETTING_TEAM_PORT_SETTING_NAME: string;
const SETTING_TEAM_PORT_STICKY: string;
const SETTING_TEAM_RUNNER: string;
const SETTING_TEAM_RUNNER_ACTIVE: string;
const SETTING_TEAM_RUNNER_ACTIVEBACKUP: string;
const SETTING_TEAM_RUNNER_AGG_SELECT_POLICY: string;
const SETTING_TEAM_RUNNER_AGG_SELECT_POLICY_BANDWIDTH: string;
const SETTING_TEAM_RUNNER_AGG_SELECT_POLICY_COUNT: string;
const SETTING_TEAM_RUNNER_AGG_SELECT_POLICY_LACP_PRIO: string;
const SETTING_TEAM_RUNNER_AGG_SELECT_POLICY_LACP_PRIO_STABLE: string;
const SETTING_TEAM_RUNNER_AGG_SELECT_POLICY_PORT_CONFIG: string;
const SETTING_TEAM_RUNNER_BROADCAST: string;
const SETTING_TEAM_RUNNER_FAST_RATE: string;
const SETTING_TEAM_RUNNER_HWADDR_POLICY: string;
const SETTING_TEAM_RUNNER_HWADDR_POLICY_BY_ACTIVE: string;
const SETTING_TEAM_RUNNER_HWADDR_POLICY_ONLY_ACTIVE: string;
const SETTING_TEAM_RUNNER_HWADDR_POLICY_SAME_ALL: string;
const SETTING_TEAM_RUNNER_LACP: string;
const SETTING_TEAM_RUNNER_LOADBALANCE: string;
const SETTING_TEAM_RUNNER_MIN_PORTS: string;
const SETTING_TEAM_RUNNER_RANDOM: string;
const SETTING_TEAM_RUNNER_ROUNDROBIN: string;
const SETTING_TEAM_RUNNER_SYS_PRIO: string;
const SETTING_TEAM_RUNNER_SYS_PRIO_DEFAULT: number;
const SETTING_TEAM_RUNNER_TX_BALANCER: string;
const SETTING_TEAM_RUNNER_TX_BALANCER_INTERVAL: string;
const SETTING_TEAM_RUNNER_TX_BALANCER_INTERVAL_DEFAULT: number;
const SETTING_TEAM_RUNNER_TX_HASH: string;
const SETTING_TEAM_SETTING_NAME: string;
const SETTING_TUN_GROUP: string;
const SETTING_TUN_MODE: string;
const SETTING_TUN_MULTI_QUEUE: string;
const SETTING_TUN_OWNER: string;
const SETTING_TUN_PI: string;
const SETTING_TUN_SETTING_NAME: string;
const SETTING_TUN_VNET_HDR: string;
const SETTING_USER_DATA: string;
const SETTING_USER_SETTING_NAME: string;
const SETTING_VETH_PEER: string;
const SETTING_VETH_SETTING_NAME: string;
const SETTING_VLAN_EGRESS_PRIORITY_MAP: string;
const SETTING_VLAN_FLAGS: string;
const SETTING_VLAN_ID: string;
const SETTING_VLAN_INGRESS_PRIORITY_MAP: string;
const SETTING_VLAN_PARENT: string;
const SETTING_VLAN_PROTOCOL: string;
const SETTING_VLAN_SETTING_NAME: string;
const SETTING_VPN_DATA: string;
const SETTING_VPN_PERSISTENT: string;
const SETTING_VPN_SECRETS: string;
const SETTING_VPN_SERVICE_TYPE: string;
const SETTING_VPN_SETTING_NAME: string;
const SETTING_VPN_TIMEOUT: string;
const SETTING_VPN_USER_NAME: string;
const SETTING_VRF_SETTING_NAME: string;
const SETTING_VRF_TABLE: string;
const SETTING_VXLAN_AGEING: string;
const SETTING_VXLAN_DESTINATION_PORT: string;
const SETTING_VXLAN_ID: string;
const SETTING_VXLAN_L2_MISS: string;
const SETTING_VXLAN_L3_MISS: string;
const SETTING_VXLAN_LEARNING: string;
const SETTING_VXLAN_LIMIT: string;
const SETTING_VXLAN_LOCAL: string;
const SETTING_VXLAN_PARENT: string;
const SETTING_VXLAN_PROXY: string;
const SETTING_VXLAN_REMOTE: string;
const SETTING_VXLAN_RSC: string;
const SETTING_VXLAN_SETTING_NAME: string;
const SETTING_VXLAN_SOURCE_PORT_MAX: string;
const SETTING_VXLAN_SOURCE_PORT_MIN: string;
const SETTING_VXLAN_TOS: string;
const SETTING_VXLAN_TTL: string;
/**
* The mac address of the peer to connect to.
*/
const SETTING_WIFI_P2P_PEER: string;
const SETTING_WIFI_P2P_SETTING_NAME: string;
const SETTING_WIFI_P2P_WFD_IES: string;
const SETTING_WIFI_P2P_WPS_METHOD: string;
const SETTING_WIMAX_MAC_ADDRESS: string;
const SETTING_WIMAX_NETWORK_NAME: string;
const SETTING_WIMAX_SETTING_NAME: string;
const SETTING_WIRED_ACCEPT_ALL_MAC_ADDRESSES: string;
const SETTING_WIRED_AUTO_NEGOTIATE: string;
const SETTING_WIRED_CLONED_MAC_ADDRESS: string;
const SETTING_WIRED_DUPLEX: string;
const SETTING_WIRED_GENERATE_MAC_ADDRESS_MASK: string;
const SETTING_WIRED_MAC_ADDRESS: string;
const SETTING_WIRED_MAC_ADDRESS_BLACKLIST: string;
const SETTING_WIRED_MAC_ADDRESS_DENYLIST: string;
const SETTING_WIRED_MTU: string;
const SETTING_WIRED_PORT: string;
const SETTING_WIRED_S390_NETTYPE: string;
const SETTING_WIRED_S390_OPTIONS: string;
const SETTING_WIRED_S390_SUBCHANNELS: string;
const SETTING_WIRED_SETTING_NAME: string;
const SETTING_WIRED_SPEED: string;
const SETTING_WIRED_WAKE_ON_LAN: string;
const SETTING_WIRED_WAKE_ON_LAN_PASSWORD: string;
const SETTING_WIREGUARD_FWMARK: string;
const SETTING_WIREGUARD_IP4_AUTO_DEFAULT_ROUTE: string;
const SETTING_WIREGUARD_IP6_AUTO_DEFAULT_ROUTE: string;
const SETTING_WIREGUARD_LISTEN_PORT: string;
const SETTING_WIREGUARD_MTU: string;
const SETTING_WIREGUARD_PEERS: string;
const SETTING_WIREGUARD_PEER_ROUTES: string;
const SETTING_WIREGUARD_PRIVATE_KEY: string;
const SETTING_WIREGUARD_PRIVATE_KEY_FLAGS: string;
const SETTING_WIREGUARD_SETTING_NAME: string;
const SETTING_WIRELESS_AP_ISOLATION: string;
const SETTING_WIRELESS_BAND: string;
const SETTING_WIRELESS_BSSID: string;
const SETTING_WIRELESS_CHANNEL: string;
const SETTING_WIRELESS_CHANNEL_WIDTH: string;
const SETTING_WIRELESS_CLONED_MAC_ADDRESS: string;
const SETTING_WIRELESS_GENERATE_MAC_ADDRESS_MASK: string;
const SETTING_WIRELESS_HIDDEN: string;
const SETTING_WIRELESS_MAC_ADDRESS: string;
const SETTING_WIRELESS_MAC_ADDRESS_BLACKLIST: string;
const SETTING_WIRELESS_MAC_ADDRESS_DENYLIST: string;
const SETTING_WIRELESS_MAC_ADDRESS_RANDOMIZATION: string;
const SETTING_WIRELESS_MODE: string;
/**
* Indicates Ad-Hoc mode where no access point is expected to be present.
*/
const SETTING_WIRELESS_MODE_ADHOC: string;
/**
* Indicates AP/master mode where the wireless device is started as an access
* point/hotspot.
*/
const SETTING_WIRELESS_MODE_AP: string;
/**
* Indicates infrastructure mode where an access point is expected to be present
* for this connection.
*/
const SETTING_WIRELESS_MODE_INFRA: string;
/**
* Indicates that the connection should create a mesh point.
*/
const SETTING_WIRELESS_MODE_MESH: string;
const SETTING_WIRELESS_MTU: string;
const SETTING_WIRELESS_POWERSAVE: string;
const SETTING_WIRELESS_RATE: string;
const SETTING_WIRELESS_SECURITY_AUTH_ALG: string;
const SETTING_WIRELESS_SECURITY_FILS: string;
const SETTING_WIRELESS_SECURITY_GROUP: string;
const SETTING_WIRELESS_SECURITY_KEY_MGMT: string;
const SETTING_WIRELESS_SECURITY_LEAP_PASSWORD: string;
const SETTING_WIRELESS_SECURITY_LEAP_PASSWORD_FLAGS: string;
const SETTING_WIRELESS_SECURITY_LEAP_USERNAME: string;
const SETTING_WIRELESS_SECURITY_PAIRWISE: string;
const SETTING_WIRELESS_SECURITY_PMF: string;
const SETTING_WIRELESS_SECURITY_PROTO: string;
const SETTING_WIRELESS_SECURITY_PSK: string;
const SETTING_WIRELESS_SECURITY_PSK_FLAGS: string;
const SETTING_WIRELESS_SECURITY_SETTING_NAME: string;
const SETTING_WIRELESS_SECURITY_WEP_KEY0: string;
const SETTING_WIRELESS_SECURITY_WEP_KEY1: string;
const SETTING_WIRELESS_SECURITY_WEP_KEY2: string;
const SETTING_WIRELESS_SECURITY_WEP_KEY3: string;
const SETTING_WIRELESS_SECURITY_WEP_KEY_FLAGS: string;
const SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE: string;
const SETTING_WIRELESS_SECURITY_WEP_TX_KEYIDX: string;
const SETTING_WIRELESS_SECURITY_WPS_METHOD: string;
const SETTING_WIRELESS_SEEN_BSSIDS: string;
const SETTING_WIRELESS_SETTING_NAME: string;
const SETTING_WIRELESS_SSID: string;
const SETTING_WIRELESS_TX_POWER: string;
const SETTING_WIRELESS_WAKE_ON_WLAN: string;
const SETTING_WPAN_CHANNEL: string;
const SETTING_WPAN_CHANNEL_DEFAULT: number;
const SETTING_WPAN_MAC_ADDRESS: string;
const SETTING_WPAN_PAGE: string;
const SETTING_WPAN_PAGE_DEFAULT: number;
const SETTING_WPAN_PAN_ID: string;
const SETTING_WPAN_SETTING_NAME: string;
const SETTING_WPAN_SHORT_ADDRESS: string;
const SRIOV_VF_ATTRIBUTE_MAC: string;
const SRIOV_VF_ATTRIBUTE_MAX_TX_RATE: string;
const SRIOV_VF_ATTRIBUTE_MIN_TX_RATE: string;
const SRIOV_VF_ATTRIBUTE_SPOOF_CHECK: string;
const SRIOV_VF_ATTRIBUTE_TRUST: string;
const TEAM_LINK_WATCHER_ARP_PING: string;
const TEAM_LINK_WATCHER_ETHTOOL: string;
const TEAM_LINK_WATCHER_NSNA_PING: string;
/**
* The maximum length of hardware addresses handled by NetworkManager itself,
* nm_utils_hwaddr_len(), and nm_utils_hwaddr_aton().
*/
const UTILS_HWADDR_LEN_MAX: number;
const VLAN_FLAGS_ALL: number;
const VPN_CONNECTION_BANNER: string;
const VPN_CONNECTION_VPN_STATE: string;
const VPN_DBUS_PLUGIN_INTERFACE: string;
const VPN_DBUS_PLUGIN_PATH: string;
const VPN_EDITOR_PLUGIN_DESCRIPTION: string;
const VPN_EDITOR_PLUGIN_NAME: string;
const VPN_EDITOR_PLUGIN_SERVICE: string;
const VPN_PLUGIN_CAN_PERSIST: string;
const VPN_PLUGIN_CONFIG_BANNER: string;
const VPN_PLUGIN_CONFIG_EXT_GATEWAY: string;
const VPN_PLUGIN_CONFIG_HAS_IP4: string;
const VPN_PLUGIN_CONFIG_HAS_IP6: string;
const VPN_PLUGIN_CONFIG_MTU: string;
const VPN_PLUGIN_CONFIG_PROXY_PAC: string;
const VPN_PLUGIN_CONFIG_TUNDEV: string;
const VPN_PLUGIN_INFO_FILENAME: string;
const VPN_PLUGIN_INFO_KEYFILE: string;
const VPN_PLUGIN_INFO_KF_GROUP_CONNECTION: string;
const VPN_PLUGIN_INFO_KF_GROUP_GNOME: string;
const VPN_PLUGIN_INFO_KF_GROUP_LIBNM: string;
const VPN_PLUGIN_INFO_NAME: string;
const VPN_PLUGIN_IP4_CONFIG_ADDRESS: string;
const VPN_PLUGIN_IP4_CONFIG_DNS: string;
const VPN_PLUGIN_IP4_CONFIG_DOMAIN: string;
const VPN_PLUGIN_IP4_CONFIG_DOMAINS: string;
const VPN_PLUGIN_IP4_CONFIG_INT_GATEWAY: string;
const VPN_PLUGIN_IP4_CONFIG_MSS: string;
const VPN_PLUGIN_IP4_CONFIG_NBNS: string;
const VPN_PLUGIN_IP4_CONFIG_NEVER_DEFAULT: string;
const VPN_PLUGIN_IP4_CONFIG_PREFIX: string;
const VPN_PLUGIN_IP4_CONFIG_PRESERVE_ROUTES: string;
const VPN_PLUGIN_IP4_CONFIG_PTP: string;
const VPN_PLUGIN_IP4_CONFIG_ROUTES: string;
const VPN_PLUGIN_IP6_CONFIG_ADDRESS: string;
const VPN_PLUGIN_IP6_CONFIG_DNS: string;
const VPN_PLUGIN_IP6_CONFIG_DOMAIN: string;
const VPN_PLUGIN_IP6_CONFIG_DOMAINS: string;
const VPN_PLUGIN_IP6_CONFIG_INT_GATEWAY: string;
const VPN_PLUGIN_IP6_CONFIG_MSS: string;
const VPN_PLUGIN_IP6_CONFIG_NEVER_DEFAULT: string;
const VPN_PLUGIN_IP6_CONFIG_PREFIX: string;
const VPN_PLUGIN_IP6_CONFIG_PRESERVE_ROUTES: string;
const VPN_PLUGIN_IP6_CONFIG_PTP: string;
const VPN_PLUGIN_IP6_CONFIG_ROUTES: string;
const VPN_PLUGIN_OLD_DBUS_SERVICE_NAME: string;
const VPN_PLUGIN_OLD_STATE: string;
const VPN_SERVICE_PLUGIN_DBUS_SERVICE_NAME: string;
const VPN_SERVICE_PLUGIN_DBUS_WATCH_PEER: string;
const VPN_SERVICE_PLUGIN_STATE: string;
const WIFI_P2P_PEER_FLAGS: string;
const WIFI_P2P_PEER_HW_ADDRESS: string;
const WIFI_P2P_PEER_LAST_SEEN: string;
const WIFI_P2P_PEER_MANUFACTURER: string;
const WIFI_P2P_PEER_MODEL: string;
const WIFI_P2P_PEER_MODEL_NUMBER: string;
const WIFI_P2P_PEER_NAME: string;
const WIFI_P2P_PEER_SERIAL: string;
const WIFI_P2P_PEER_STRENGTH: string;
const WIFI_P2P_PEER_WFD_IES: string;
const WIMAX_NSP_NAME: string;
const WIMAX_NSP_NETWORK_TYPE: string;
const WIMAX_NSP_SIGNAL_QUALITY: string;
const WIREGUARD_PEER_ATTR_ALLOWED_IPS: string;
const WIREGUARD_PEER_ATTR_ENDPOINT: string;
const WIREGUARD_PEER_ATTR_PERSISTENT_KEEPALIVE: string;
const WIREGUARD_PEER_ATTR_PRESHARED_KEY: string;
const WIREGUARD_PEER_ATTR_PRESHARED_KEY_FLAGS: string;
const WIREGUARD_PEER_ATTR_PUBLIC_KEY: string;
const WIREGUARD_PUBLIC_KEY_LEN: number;
const WIREGUARD_SYMMETRIC_KEY_LEN: number;
function agent_manager_error_quark(): GLib.Quark;
/**
* Parses the string representation of the queueing
* discipline to a %NMBridgeVlan instance.
* @param str the string representation of a bridge VLAN
* @returns the %NMBridgeVlan or %NULL
*/
function bridge_vlan_from_str(str: string): BridgeVlan;
/**
* Registers an error quark for #NMClient if necessary.
* @returns the error quark used for #NMClient errors.
*/
function client_error_quark(): GLib.Quark;
function conn_wireguard_import(filename: string): Connection;
function connection_error_quark(): GLib.Quark;
function crypto_error_quark(): GLib.Quark;
function device_error_quark(): GLib.Quark;
/**
* Checks whether `optname` is a valid option name for a channels setting.
* @param optname the option name to check
* @returns %TRUE, if @optname is valid
*/
function ethtool_optname_is_channels(optname?: string | null): boolean;
/**
* Checks whether `optname` is a valid option name for a coalesce setting.
* @param optname the option name to check
* @returns %TRUE, if @optname is valid
*/
function ethtool_optname_is_coalesce(optname?: string | null): boolean;
/**
* Checks whether `optname` is a valid option name for an eee setting.
* @param optname the option name to check
* @returns %TRUE, if @optname is valid
*/
function ethtool_optname_is_eee(optname?: string | null): boolean;
/**
* Checks whether `optname` is a valid option name for an offload feature.
* @param optname the option name to check
* @returns %TRUE, if @optname is valid Note that nm_ethtool_optname_is_feature() was first added to the libnm header files in 1.14.0 but forgot to actually add to the library. This happened belatedly in 1.20.0 and the stable versions 1.18.2, 1.16.4 and 1.14.8 (with linker version "libnm_1_14_8").
*/
function ethtool_optname_is_feature(optname?: string | null): boolean;
/**
* Checks whether `optname` is a valid option name for a fec setting.
* @param optname the option name to check
* @returns %TRUE, if @optname is valid
*/
function ethtool_optname_is_fec(optname?: string | null): boolean;
/**
* Checks whether `optname` is a valid option name for a pause setting.
* @param optname the option name to check
* @returns %TRUE, if @optname is valid
*/
function ethtool_optname_is_pause(optname?: string | null): boolean;
/**
* Checks whether `optname` is a valid option name for a ring setting.
* @param optname the option name to check
* @returns %TRUE, if @optname is valid
*/
function ethtool_optname_is_ring(optname?: string | null): boolean;
/**
* Validates a route attribute, i.e. checks that the attribute is a known one
* and the value is of the correct type and well-formed.
* @param name the attribute name
* @param value the attribute value
* @param family IP address family of the route
* @returns %TRUE if the attribute is valid, %FALSE otherwise
*/
function ip_route_attribute_validate(name: string, value: GLib.Variant, family: number): [boolean, boolean];
function ip_route_get_variant_attribute_spec(): VariantAttributeSpec;
function ip_routing_rule_from_string(
str: string,
to_string_flags: IPRoutingRuleAsStringFlags | null,
extra_args?: GLib.HashTable | null,
): IPRoutingRule;
/**
* Tries to create a NMConnection from a keyfile. The resulting keyfile is
* not normalized and might not even verify.
* @param keyfile the keyfile from which to create the connection
* @param base_dir when reading certificates from files with relative name, the relative path is made absolute using @base_dir. This must be an absolute path.
* @param handler_flags the #NMKeyfileHandlerFlags.
* @param handler read handler
* @returns on success, returns the created connection.
*/
function keyfile_read(
keyfile: GLib.KeyFile,
base_dir: string,
handler_flags: KeyfileHandlerFlags | null,
handler?: KeyfileReadHandler | null,
): Connection;
/**
* `connection` should verify as a valid profile according to
* nm_connection_verify(). If it does not verify, the keyfile may
* be incomplete and the parser may not be able to fully recreate
* the original profile.
* @param connection the #NMConnection to persist to keyfile.
* @param handler_flags the #NMKeyfileHandlerFlags.
* @param handler optional handler for events and to override the default behavior.
* @returns a new #GKeyFile or %NULL on error.
*/
function keyfile_write(
connection: Connection,
handler_flags: KeyfileHandlerFlags | null,
handler?: KeyfileWriteHandler | null,
): GLib.KeyFile;
function manager_error_quark(): GLib.Quark;
/**
* Parses the string representation of the range to create a %NMRange
* instance.
* @param str the string representation of a range
* @returns the %NMRange or %NULL
*/
function range_from_str(str: string): Range;
function secret_agent_error_quark(): GLib.Quark;
function settings_error_quark(): GLib.Quark;
/**
* Validates a VF attribute, i.e. checks that the attribute is a known one,
* the value is of the correct type and well-formed.
* @param name the attribute name
* @param value the attribute value
* @returns %TRUE if the attribute is valid, %FALSE otherwise
*/
function sriov_vf_attribute_validate(name: string, value: GLib.Variant): [boolean, boolean];
/**
* Given a set of device capabilities, and a desired security type to check
* against, determines whether the combination of device capabilities and
* desired security type are valid for AP/Hotspot connections.
* @param type the security type to check device capabilities against, e.g. #NMU_SEC_STATIC_WEP
* @param wifi_caps bitfield of the capabilities of the specific Wi-Fi device, e.g. #NM_WIFI_DEVICE_CAP_CIPHER_WEP40
* @returns %TRUE if the device capabilities are compatible with the desired @type, %FALSE if they are not.
*/
function utils_ap_mode_security_valid(
type: UtilsSecurityType | null,
wifi_caps: DeviceWifiCapabilities | null,
): boolean;
function utils_base64secret_decode(base64_key: string, required_key_len: number): [boolean, number];
/**
* Converts the byte array `src` into a hexadecimal string. If `final_len` is
* greater than -1, the returned string is terminated at that index
* (returned_string[final_len] == '\0'),
* @param src an array of bytes
* @param final_len an index where to cut off the returned string, or -1
* @returns the textual form of @bytes
*/
function utils_bin2hexstr(src: Uint8Array | string, final_len: number): string;
/**
* Convert bonding mode from integer value to descriptive name.
* See https://www.kernel.org/doc/Documentation/networking/bonding.txt for
* available modes.
* @param mode bonding mode as a numeric value
* @returns bonding mode string, or NULL on error
*/
function utils_bond_mode_int_to_string(mode: number): string;
/**
* Convert bonding mode from string representation to numeric value.
* See https://www.kernel.org/doc/Documentation/networking/bonding.txt for
* available modes.
* The `mode` string can be either a descriptive name or a number (as string).
* @param mode bonding mode as string
* @returns numeric bond mode, or -1 on error
*/
function utils_bond_mode_string_to_int(mode: string): number;
/**
* Determines if a connection of type `virtual_type` can (in the
* general case) work with connections of type `other_type`.
*
* If `virtual_type` is %NM_TYPE_SETTING_VLAN, then this checks if
* `other_type` is a valid type for the parent of a VLAN.
*
* If `virtual_type` is a "controller" type (eg, %NM_TYPE_SETTING_BRIDGE),
* then this checks if `other_type` is a valid type for a port of that
* controller.
*
* Note that even if this returns %TRUE it is not guaranteed that
* every connection of type `other_type` is
* compatible with `virtual_type;` it may depend on the exact
* configuration of the two connections, or on the capabilities of an
* underlying device driver.
* @param virtual_type a virtual connection type
* @param other_type a connection type to test against @virtual_type
* @returns %TRUE or %FALSE
*/
function utils_check_virtual_device_compatibility(
virtual_type: GObject.GType,
other_type: GObject.GType,
): boolean;
/**
* This ensures that all NMSetting GTypes are created. For example,
* after this call, g_type_from_name("NMSettingConnection") will work.
*
* This cannot fail and does nothing if the type already exists.
*/
function utils_ensure_gtypes(): void;
/**
* Converts a string to the matching enum value.
*
* If the enum is a %G_TYPE_FLAGS the function returns the logical OR of values
* matching the comma-separated tokens in the string; if an unknown token is found
* the function returns %FALSE and stores a pointer to a newly allocated string
* containing the unrecognized token in `err_token`.
* @param type the %GType of the enum
* @param str the input string
* @returns %TRUE if the conversion was successful, %FALSE otherwise
*/
function utils_enum_from_str(type: GObject.GType, str: string): [boolean, number, string];
/**
* Returns the list of possible values for a given enum.
* @param type the %GType of the enum
* @param from the first element to be returned
* @param to the last element to be returned
* @returns a NULL-terminated dynamically-allocated array of static strings or %NULL on error
*/
function utils_enum_get_values(type: GObject.GType, from: number, to: number): string[];
/**
* Converts an enum value to its string representation. If the enum is a
* %G_TYPE_FLAGS the function returns a comma-separated list of matching values.
* If the value has no corresponding string representation, it is converted
* to a number. For enums it is converted to a decimal number, for flags
* to an (unsigned) hex number.
* @param type the %GType of the enum
* @param value the value to be translated
* @returns a newly allocated string or %NULL
*/
function utils_enum_to_str(type: GObject.GType, value: number): string;
/**
* This function does a quick printable character conversion of the SSID, simply
* replacing embedded NULLs and non-printable characters with the hexadecimal
* representation of that character. Intended for debugging only, should not
* be used for display of SSIDs.
*
* Warning: this function uses a static buffer. It is not thread-safe. Don't
* use this function.
* @param ssid pointer to a buffer containing the SSID data
* @returns pointer to the escaped SSID, which uses an internal static buffer and will be overwritten by subsequent calls to this function
*/
function utils_escape_ssid(ssid: Uint8Array | string): string;
/**
* Tests if `filename` has a valid extension for an X.509 certificate file
* (".cer", ".crt", ".der", or ".pem"), and contains a certificate in a format
* recognized by NetworkManager.
* @param filename name of the file to test
* @returns %TRUE if the file is a certificate, %FALSE if it is not
*/
function utils_file_is_certificate(filename: string): boolean;
/**
* Tests if `filename` is a PKCS#12 file.
* @param filename name of the file to test
* @returns %TRUE if the file is PKCS#12, %FALSE if it is not
*/
function utils_file_is_pkcs12(filename: string): boolean;
/**
* Tests if `filename` has a valid extension for an X.509 private key file
* (".der", ".key", ".pem", or ".p12"), and contains a private key in a format
* recognized by NetworkManager.
* @param filename name of the file to test
* @returns %TRUE if the file is a private key, %FALSE if it is not
*/
function utils_file_is_private_key(filename: string): [boolean, boolean];
/**
* Searches for a `progname` file in a list of search `paths`.
* @param progname the helper program name, like "iptables" Must be a non-empty string, without path separator (/).
* @param try_first a custom path to try first before searching. It is silently ignored if it is empty or not an absolute path.
* @param paths a %NULL terminated list of search paths. Can be empty or %NULL, in which case only @try_first is checked.
* @param file_test_flags the flags passed to g_file_test() when searching for @progname. Set it to 0 to skip the g_file_test().
* @param predicate if given, pass the file name to this function for additional checks. This check is performed after the check for @file_test_flags. You cannot omit both @file_test_flags and @predicate.
* @returns the full path to the helper, if found, or %NULL if not found. The returned string is not owned by the caller, but later invocations of the function might overwrite it.
*/
function utils_file_search_in_paths(
progname: string,
try_first: string | null,
paths: string | null,
file_test_flags: GLib.FileTest | null,
predicate: UtilsFileSearchInPathsPredicate,
): string;
/**
* Format attributes to a string.
* @param attributes a #GHashTable mapping attribute names to #GVariant values
* @param attr_separator the attribute separator character
* @param key_value_separator character separating key and values
* @returns the string representing attributes, or %NULL in case there are no attributes
*/
function utils_format_variant_attributes(
attributes: { [key: string]: any } | GLib.HashTable,
attr_separator: number,
key_value_separator: number,
): string;
/**
* Gets current time in milliseconds of CLOCK_BOOTTIME.
* @returns time in milliseconds
*/
function utils_get_timestamp_msec(): number;
/**
* Converts a hexadecimal string `hex` into an array of bytes. The optional
* separator ':' may be used between single or pairs of hexadecimal characters,
* eg "00:11" or "0:1". Any "0x" at the beginning of `hex` is ignored. `hex`
* may not start or end with ':'.
* @param hex a string of hexadecimal characters with optional ':' separators
* @returns the converted bytes, or %NULL on error
*/
function utils_hexstr2bin(hex: string): GLib.Bytes;
/**
* Parses `asc` and converts it to binary form in a #GByteArray. See
* nm_utils_hwaddr_aton() if you don't want a #GByteArray.
* @param asc the ASCII representation of a hardware address
* @param length the expected length in bytes of the result
* @returns a new #GByteArray, or %NULL if @asc couldn't be parsed
*/
function utils_hwaddr_atoba(asc: string, length: number): Uint8Array;
/**
* Parses `asc` and converts it to binary form in `buffer`.
* Bytes in `asc` can be separated by colons (:), or hyphens (-), but not mixed.
* @param asc the ASCII representation of a hardware address
* @param buffer buffer to store the result into
* @returns @buffer, or %NULL if @asc couldn't be parsed or would be shorter or longer than @length.
*/
function utils_hwaddr_aton(asc: string, buffer: Uint8Array | string): number;
/**
* Parses `asc` to see if it is a valid hardware address of the given
* length, and if so, returns it in canonical form (uppercase, with
* leading 0s as needed, and with colons rather than hyphens).
* @param asc the ASCII representation of a hardware address
* @param length the length of address that @asc is expected to convert to (or -1 to accept any length up to %NM_UTILS_HWADDR_LEN_MAX)
* @returns the canonicalized address if @asc appears to be a valid hardware address of the indicated length, %NULL if not.
*/
function utils_hwaddr_canonical(asc: string, length: number): string;
/**
* Returns the length in octets of a hardware address of type `type`.
*
* Before 1.28, it was an error to call this function with any value other than
* ARPHRD_ETHER or ARPHRD_INFINIBAND.
* @param type the type of address; either ARPHRD_ETHER or ARPHRD_INFINIBAND
* @returns the length or zero if the type is unrecognized.
*/
function utils_hwaddr_len(type: number): number;
/**
* Generalized hardware address comparison function. Tests if `hwaddr1` and
* `hwaddr2` "equal" (or more precisely, "equivalent"), with several advantages
* over a simple memcmp():
*
* 1. If `hwaddr1`_len or `hwaddr2`_len is -1, then the corresponding address is
* assumed to be ASCII rather than binary, and will be converted to binary
* before being compared.
*
* 2. If `hwaddr1` or `hwaddr2` is %NULL, it is treated instead as though it was
* a zero-filled buffer `hwaddr1`_len or `hwaddr2`_len bytes long.
*
* 3. If `hwaddr1` and `hwaddr2` are InfiniBand hardware addresses (that is, if
* they are INFINIBAND_ALEN bytes long in binary form)
* then only the last 8 bytes are compared, since those are the only bytes
* that actually identify the hardware. (The other 12 bytes will change
* depending on the configuration of the InfiniBand fabric that the device
* is connected to.)
*
* If a passed-in ASCII hardware address cannot be parsed, or would parse to an
* address larger than %NM_UTILS_HWADDR_LEN_MAX, then it will silently fail to
* match. (This means that externally-provided address strings do not need to be
* sanity-checked before comparing them against known good addresses; they are
* guaranteed to not match if they are invalid.)
* @param hwaddr1 pointer to a binary or ASCII hardware address, or %NULL
* @param hwaddr1_len size of @hwaddr1, or -1 if @hwaddr1 is ASCII
* @param hwaddr2 pointer to a binary or ASCII hardware address, or %NULL
* @param hwaddr2_len size of @hwaddr2, or -1 if @hwaddr2 is ASCII
* @returns %TRUE if @hwaddr1 and @hwaddr2 are equivalent, %FALSE if they are different (or either of them is invalid).
*/
function utils_hwaddr_matches(
hwaddr1: any | null,
hwaddr1_len: number,
hwaddr2: any | null,
hwaddr2_len: number,
): boolean;
/**
* Converts `addr` to textual form.
* @param addr a binary hardware address
* @returns the textual form of @addr
*/
function utils_hwaddr_ntoa(addr: Uint8Array | string): string;
/**
* Parses `asc` to see if it is a valid hardware address of the given
* length.
* @param asc the ASCII representation of a hardware address
* @param length the length of address that @asc is expected to convert to (or -1 to accept any length up to %NM_UTILS_HWADDR_LEN_MAX)
* @returns %TRUE if @asc appears to be a valid hardware address of the indicated length, %FALSE if not.
*/
function utils_hwaddr_valid(asc: string, length: number): boolean;
/**
* Validate the network interface name.
* @param name Name of interface
* @returns %TRUE if interface name is valid, otherwise %FALSE is returned. Before 1.20, this function did not accept %NULL as @name argument. If you want to run against older versions of libnm, don't pass %NULL.
*/
function utils_iface_valid_name(name?: string | null): boolean;
/**
* Utility function to convert a #GVariant of type 'aau' representing a list of
* NetworkManager IPv4 addresses (which are tuples of address, prefix, and
* gateway) into a #GPtrArray of #NMIPAddress objects. The "gateway" field of
* the first address (if set) will be returned in `out_gateway;` the "gateway" fields
* of the other addresses are ignored. Note that invalid addresses are discarded
* but the valid addresses are still returned.
*
* Since 1.46, an empty list is returned if the variant type is not valid
* (before it was checked as assertion)
* @param value a #GVariant of type 'aau'
* @returns a newly allocated #GPtrArray of #NMIPAddress objects
*/
function utils_ip4_addresses_from_variant(value: GLib.Variant): [IPAddress[], string];
/**
* Utility function to convert a #GPtrArray of #NMIPAddress objects representing
* IPv4 addresses into a #GVariant of type 'aau' representing an array of
* NetworkManager IPv4 addresses (which are tuples of address, prefix, and
* gateway). The "gateway" field of the first address will get the value of
* `gateway` (if non-%NULL). In all of the other addresses, that field will be 0.
* @param addresses an array of #NMIPAddress objects
* @param gateway the gateway IP address
* @returns a new floating #GVariant representing @addresses.
*/
function utils_ip4_addresses_to_variant(addresses: IPAddress[], gateway?: string | null): GLib.Variant;
/**
* Utility function to convert a #GVariant of type 'au' representing a list of
* IPv4 addresses into an array of IP address strings.
*
* Since 1.46, an empty list is returned if the variant type is not valid
* (before it was checked as assertion)
* @param value a #GVariant of type 'au'
* @returns a %NULL-terminated array of IP address strings.
*/
function utils_ip4_dns_from_variant(value: GLib.Variant): string;
/**
* Utility function to convert an array of IP address strings int a #GVariant of
* type 'au' representing an array of IPv4 addresses.
* @param dns an array of IP address strings
* @returns a new floating #GVariant representing @dns.
*/
function utils_ip4_dns_to_variant(dns: string): GLib.Variant;
/**
* When the Internet was originally set up, various ranges of IP addresses were
* segmented into three network classes: A, B, and C. This function will return
* a prefix that is associated with the IP address specified defining where it
* falls in the predefined classes.
* @param ip an IPv4 address (in network byte order)
* @returns the default class prefix for the given IP
*/
function utils_ip4_get_default_prefix(ip: number): number;
function utils_ip4_netmask_to_prefix(netmask: number): number;
function utils_ip4_prefix_to_netmask(prefix: number): number;
/**
* Utility function to convert a #GVariant of type 'aau' representing an array
* of NetworkManager IPv4 routes (which are tuples of route, prefix, next hop,
* and metric) into a #GPtrArray of #NMIPRoute objects. Note that invalid routes
* are discarded but the valid routes are still returned.
*
* Since 1.46, an empty list is returned if the variant type is not valid
* (before it was checked as assertion)
* @param value #GVariant of type 'aau'
* @returns a newly allocated #GPtrArray of #NMIPRoute objects
*/
function utils_ip4_routes_from_variant(value: GLib.Variant): IPRoute[];
/**
* Utility function to convert a #GPtrArray of #NMIPRoute objects representing
* IPv4 routes into a #GVariant of type 'aau' representing an array of
* NetworkManager IPv4 routes (which are tuples of route, prefix, next hop, and
* metric).
* @param routes an array of #NMIP4Route objects
* @returns a new floating #GVariant representing @routes.
*/
function utils_ip4_routes_to_variant(routes: IPRoute[]): GLib.Variant;
/**
* Utility function to convert a #GVariant of type 'a(ayuay)' representing a
* list of NetworkManager IPv6 addresses (which are tuples of address, prefix,
* and gateway) into a #GPtrArray of #NMIPAddress objects. The "gateway" field
* of the first address (if set) will be returned in `out_gateway;` the "gateway"
* fields of the other addresses are ignored. Note that invalid addresses are
* discarded but the valid addresses are still returned.
*
* Since 1.46, an empty list is returned if the variant type is not valid
* (before it was checked as assertion)
* @param value a #GVariant of type 'a(ayuay)'
* @returns a newly allocated #GPtrArray of #NMIPAddress objects
*/
function utils_ip6_addresses_from_variant(value: GLib.Variant): [IPAddress[], string];
/**
* Utility function to convert a #GPtrArray of #NMIPAddress objects representing
* IPv6 addresses into a #GVariant of type 'a(ayuay)' representing an array of
* NetworkManager IPv6 addresses (which are tuples of address, prefix, and
* gateway). The "gateway" field of the first address will get the value of
* `gateway` (if non-%NULL). In all of the other addresses, that field will be
* all 0s.
* @param addresses an array of #NMIPAddress objects
* @param gateway the gateway IP address
* @returns a new floating #GVariant representing @addresses.
*/
function utils_ip6_addresses_to_variant(addresses: IPAddress[], gateway?: string | null): GLib.Variant;
/**
* Utility function to convert a #GVariant of type 'aay' representing a list of
* IPv6 addresses into an array of IP address strings. Each "ay" entry must be
* a IPv6 address in binary form (16 bytes long). Invalid entries are silently
* ignored.
*
* Since 1.46, an empty list is returned if the variant type is not valid
* (before it was checked as assertion)
* @param value a #GVariant of type 'aay'
* @returns a %NULL-terminated array of IP address strings.
*/
function utils_ip6_dns_from_variant(value: GLib.Variant): string;
/**
* Utility function to convert an array of IP address strings int a #GVariant of
* type 'aay' representing an array of IPv6 addresses.
*
* If a string cannot be parsed, it will be silently ignored.
* @param dns an array of IP address strings
* @returns a new floating #GVariant representing @dns.
*/
function utils_ip6_dns_to_variant(dns: string): GLib.Variant;
/**
* Utility function to convert a #GVariant of type 'a(ayuayu)' representing an
* array of NetworkManager IPv6 routes (which are tuples of route, prefix, next
* hop, and metric) into a #GPtrArray of #NMIPRoute objects. Note that invalid
* routes are ignored but the valid ones are still returned.
*
* Since 1.46, an empty list is returned if the variant type is not valid
* (before it was checked as assertion)
* @param value #GVariant of type 'a(ayuayu)'
* @returns a newly allocated #GPtrArray of #NMIPRoute objects
*/
function utils_ip6_routes_from_variant(value: GLib.Variant): IPRoute[];
/**
* Utility function to convert a #GPtrArray of #NMIPRoute objects representing
* IPv6 routes into a #GVariant of type 'a(ayuayu)' representing an array of
* NetworkManager IPv6 routes (which are tuples of route, prefix, next hop, and
* metric).
* @param routes an array of #NMIPRoute objects
* @returns a new floating #GVariant representing @routes.
*/
function utils_ip6_routes_to_variant(routes: IPRoute[]): GLib.Variant;
/**
* Utility function to convert a #GVariant representing a list of new-style
* NetworkManager IPv4 or IPv6 addresses (as described in the documentation for
* nm_utils_ip_addresses_to_variant()) into a #GPtrArray of #NMIPAddress
* objects. Note that invalid addresses are discarded but the valid addresses
* are still returned.
*
* Since 1.46, an empty list is returned if the variant type is not valid
* (before it was checked as assertion)
* @param value a #GVariant of type 'aa{sv}'
* @param family an IP address family
* @returns a newly allocated #GPtrArray of #NMIPAddress objects
*/
function utils_ip_addresses_from_variant(value: GLib.Variant, family: number): IPAddress[];
/**
* Utility function to convert a #GPtrArray of #NMIPAddress objects representing
* IPv4 or IPv6 addresses into a #GVariant of type 'aa{sv}' representing an
* array of new-style NetworkManager IP addresses. All addresses will include
* "address" (an IP address string), and "prefix" (a uint). Some addresses may
* include additional attributes.
* @param addresses an array of #NMIPAddress objects
* @returns a new floating #GVariant representing @addresses.
*/
function utils_ip_addresses_to_variant(addresses: IPAddress[]): GLib.Variant;
/**
* Utility function to convert a #GVariant representing a list of new-style
* NetworkManager IPv4 or IPv6 addresses (as described in the documentation for
* nm_utils_ip_routes_to_variant()) into a #GPtrArray of #NMIPRoute objects.
* Invalid routes are discarded but the valid routes are still returned.
*
* Since 1.46, an empty list is returned if the variant type is not valid
* (before it was checked as assertion)
* @param value a #GVariant of type 'aa{sv}'
* @param family an IP address family
* @returns a newly allocated #GPtrArray of #NMIPRoute objects
*/
function utils_ip_routes_from_variant(value: GLib.Variant, family: number): IPRoute[];
/**
* Utility function to convert a #GPtrArray of #NMIPRoute objects representing
* IPv4 or IPv6 routes into a #GVariant of type 'aa{sv}' representing an array
* of new-style NetworkManager IP routes. All routes will include "dest" (an IP
* address string), "prefix" (an uint) and optionally "next-hop" (an IP address
* string) and "metric" (an uint). Some routes may include additional attributes.
* Note that invalid routes are discarded and only a warning is emitted, but the
* valid routes are still returned.
* @param routes an array of #NMIPRoute objects
* @returns a new floating #GVariant representing @routes.
*/
function utils_ip_routes_to_variant(routes: IPRoute[]): GLib.Variant;
/**
* Checks if `ip` contains a valid IP address of the given family.
* @param family AF_INET or AF_INET6, or AF_UNSPEC to accept either
* @param ip an IP address
* @returns %TRUE or %FALSE
*/
function utils_ipaddr_valid(family: number, ip: string): boolean;
/**
* Different manufacturers use different mechanisms for not broadcasting the
* AP's SSID. This function attempts to detect blank/empty SSIDs using a
* number of known SSID-cloaking methods.
* @param ssid pointer to a buffer containing the SSID data
* @returns %TRUE if the SSID is "empty", %FALSE if it is not
*/
function utils_is_empty_ssid(ssid: Uint8Array | string): boolean;
function utils_is_json_object(str: string): boolean;
/**
* Checks if `str` is a UUID
* @param str a string that might be a UUID
* @returns %TRUE if @str is a UUID, %FALSE if not In older versions, nm_utils_is_uuid() did not accept %NULL as @str argument. Don't pass %NULL if you run against older versions of libnm.
*/
function utils_is_uuid(str?: string | null): boolean;
/**
* Validate the network interface name.
*
* This function is a 1:1 copy of the kernel's interface validation
* function in net/core/dev.c.
* @param name Name of interface
* @returns %TRUE if interface name is valid, otherwise %FALSE is returned. Before 1.20, this function did not accept %NULL as @name argument. If you want to run against older versions of libnm, don't pass %NULL.
*/
function utils_is_valid_iface_name(name?: string | null): boolean;
/**
* Parse attributes from a string.
* @param string the input string
* @param attr_separator the attribute separator character
* @param key_value_separator character separating key and values
* @param ignore_unknown whether unknown attributes should be ignored
* @param spec the attribute format specifiers
* @returns a #GHashTable mapping attribute names to #GVariant values. Warning: the variant are still floating references, owned by the hash table. If you take a reference, ensure to sink the one of the hash table first.
*/
function utils_parse_variant_attributes(
string: string,
attr_separator: number,
key_value_separator: number,
ignore_unknown: boolean,
spec: VariantAttributeSpec,
): GLib.HashTable;
/**
* The only purpose of this function is to give access to g_print()
* or g_printerr() from pygobject. libnm can do debug logging by
* setting LIBNM_CLIENT_DEBUG and uses thereby g_printerr() or
* g_print(). A plain "print()" function in python is not in sync
* with these functions (it implements additional buffering). By
* using nm_utils_print(), the same logging mechanisms can be used.
*
* LIBNM_CLIENT_DEBUG is a list of keywords separated by commas. The keyword
* "trace" enables printing messages of the lowest up to the highest severity.
* Likewise, the severities "debug", "warn" ("warning") and "error" are honored
* in similar way. Setting the flags "ERROR" or "WARN" ("WARNING") implies that
* respective levels are enabled, but also are ERROR messages printed with
* g_critical() and WARN messages with g_warning(). Together with G_DEBUG="fatal-warnings"
* or G_DEBUG="fatal-critical" this can be used to abort the program on errors.
* Note that all <error> messages imply an unexpected data on the D-Bus API
* (due to a bug). <warn> also implies unexepected data, but that can happen
* when using different versions of libnm and daemon. For testing, it is
* good to turn these into assertions.
*
* By default, messages are printed to stderr, unless LIBNM_CLIENT_DEBUG
* contains "stdout" flag. Also, libnm honors LIBNM_CLIENT_DEBUG_FILE
* environment. If this is set to a filename pattern (accepting "%%p" for the
* process ID), then the debug log is written to that file instead of
* stderr/stdout. With `output_mode` zero, the same location will be written.
*
* LIBNM_CLIENT_DEBUG_FILE is supported since 1.44. "ERROR", "WARN" and "WARNING"
* are supported since 1.46.
* @param output_mode if 1 it uses g_print(). If 2, it uses g_printerr(). If 0, it uses the same output as internal libnm debug logging does. That is, depending on LIBNM_CLIENT_DEBUG's "stdout" flag it uses g_print() or g_printerr() and if LIBNM_CLIENT_DEBUG_FILE is set, it writes the output to file instead
* @param msg the message to print. The function does not append a trailing newline.
*/
function utils_print(output_mode: number, msg: string): void;
/**
* Earlier versions of the Linux kernel added a NULL byte to the end of the
* SSID to enable easy printing of the SSID on the console or in a terminal,
* but this behavior was problematic (SSIDs are simply byte arrays, not strings)
* and thus was changed. This function compensates for that behavior at the
* cost of some compatibility with odd SSIDs that may legitimately have trailing
* NULLs, even though that is functionally pointless.
* @param ssid1 the first SSID to compare
* @param ssid2 the second SSID to compare
* @param ignore_trailing_null %TRUE to ignore one trailing NULL byte
* @returns %TRUE if the SSIDs are the same, %FALSE if they are not
*/
function utils_same_ssid(
ssid1: Uint8Array | string,
ssid2: Uint8Array | string,
ignore_trailing_null: boolean,
): boolean;
/**
* Given a set of device capabilities, and a desired security type to check
* against, determines whether the combination of device, desired security
* type, and AP capabilities intersect.
*
* NOTE: this function cannot handle checking security for AP/Hotspot mode;
* use nm_utils_ap_mode_security_valid() instead.
* @param type the security type to check AP flags and device capabilities against, e.g. #NMU_SEC_STATIC_WEP
* @param wifi_caps bitfield of the capabilities of the specific Wi-Fi device, e.g. #NM_WIFI_DEVICE_CAP_CIPHER_WEP40
* @param have_ap whether the @ap_flags, @ap_wpa, and @ap_rsn arguments are valid
* @param adhoc whether the capabilities being tested are from an Ad-Hoc AP (IBSS)
* @param ap_flags bitfield of AP capabilities, e.g. #NM_802_11_AP_FLAGS_PRIVACY
* @param ap_wpa bitfield of AP capabilities derived from the AP's WPA beacon, e.g. (#NM_802_11_AP_SEC_PAIR_TKIP | #NM_802_11_AP_SEC_KEY_MGMT_PSK)
* @param ap_rsn bitfield of AP capabilities derived from the AP's RSN/WPA2 beacon, e.g. (#NM_802_11_AP_SEC_PAIR_CCMP | #NM_802_11_AP_SEC_PAIR_TKIP)
* @returns %TRUE if the device capabilities and AP capabilities intersect and are compatible with the desired @type, %FALSE if they are not
*/
function utils_security_valid(
type: UtilsSecurityType | null,
wifi_caps: DeviceWifiCapabilities | null,
have_ap: boolean,
adhoc: boolean,
ap_flags: __80211ApFlags,
ap_wpa: __80211ApSecurityFlags,
ap_rsn: __80211ApSecurityFlags,
): boolean;
/**
* Converts a string to a SR-IOV virtual function object.
* @param str the input string
* @returns the virtual function object
*/
function utils_sriov_vf_from_str(str: string): SriovVF;
/**
* Converts a SR-IOV virtual function object to its string representation.
* @param vf the %NMSriovVF
* @param omit_index if %TRUE, the VF index will be omitted from output string
* @returns a newly allocated string or %NULL on error
*/
function utils_sriov_vf_to_str(vf: SriovVF, omit_index: boolean): string;
/**
* Wi-Fi SSIDs are byte arrays, they are _not_ strings. Thus, an SSID may
* contain embedded NULLs and other unprintable characters. Often it is
* useful to print the SSID out for debugging purposes, but that should be the
* _only_ use of this function. Do not use this function for any persistent
* storage of the SSID, since the printable SSID returned from this function
* cannot be converted back into the real SSID of the access point.
*
* This function does almost everything humanly possible to convert the input
* into a printable UTF-8 string, using roughly the following procedure:
*
* 1) if the input data is already UTF-8 safe, no conversion is performed
* 2) attempts to get the current system language from the LANG environment
* variable, and depending on the language, uses a table of alternative
* encodings to try. For example, if LANG=hu_HU, the table may first try
* the ISO-8859-2 encoding, and if that fails, try the Windows-1250 encoding.
* If all fallback encodings fail, replaces non-UTF-8 characters with '?'.
* 3) If the system language was unable to be determined, falls back to the
* ISO-8859-1 encoding, then to the Windows-1251 encoding.
* 4) If step 3 fails, replaces non-UTF-8 characters with '?'.
*
* Again, this function should be used for debugging and display purposes
* _only_.
* @param ssid pointer to a buffer containing the SSID data
* @returns an allocated string containing a UTF-8 representation of the SSID, which must be freed by the caller using g_free(). Returns %NULL on errors.
*/
function utils_ssid_to_utf8(ssid: Uint8Array | string): string;
/**
* Parses the tc style string action representation of the queueing
* discipline to a %NMTCAction instance. Supports a subset of the tc language.
* @param str the string representation of a action
* @returns the %NMTCAction or %NULL
*/
function utils_tc_action_from_str(str: string): TCAction;
/**
* Turns the %NMTCAction into a tc style string representation of the queueing
* discipline.
* @param action the %NMTCAction
* @returns formatted string or %NULL
*/
function utils_tc_action_to_str(action: TCAction): string;
/**
* Parses the tc style string qdisc representation of the queueing
* discipline to a %NMTCQdisc instance. Supports a subset of the tc language.
* @param str the string representation of a qdisc
* @returns the %NMTCQdisc or %NULL
*/
function utils_tc_qdisc_from_str(str: string): TCQdisc;
/**
* Turns the %NMTCQdisc into a tc style string representation of the queueing
* discipline.
* @param qdisc the %NMTCQdisc
* @returns formatted string or %NULL
*/
function utils_tc_qdisc_to_str(qdisc: TCQdisc): string;
/**
* Parses the tc style string tfilter representation of the queueing
* discipline to a %NMTCTfilter instance. Supports a subset of the tc language.
* @param str the string representation of a tfilter
* @returns the %NMTCTfilter or %NULL
*/
function utils_tc_tfilter_from_str(str: string): TCTfilter;
/**
* Turns the %NMTCTfilter into a tc style string representation of the queueing
* discipline.
* @param tfilter the %NMTCTfilter
* @returns formatted string or %NULL
*/
function utils_tc_tfilter_to_str(tfilter: TCTfilter): string;
function utils_uuid_generate(): string;
function utils_version(): number;
/**
* Checks if `key` is a valid WEP key
* @param key a string that might be a WEP key
* @param wep_type the #NMWepKeyType type of the WEP key
* @returns %TRUE if @key is a WEP key, %FALSE if not
*/
function utils_wep_key_valid(key: string, wep_type: WepKeyType | null): boolean;
/**
* Utility function to return 2.4 GHz Wi-Fi frequencies (802.11bg band).
* @returns zero-terminated array of frequencies numbers (in MHz)
*/
function utils_wifi_2ghz_freqs(): number;
/**
* Utility function to return 5 GHz Wi-Fi frequencies (802.11a band).
* @returns zero-terminated array of frequencies numbers (in MHz)
*/
function utils_wifi_5ghz_freqs(): number;
/**
* Utility function to translate a Wi-Fi channel to its corresponding frequency.
* @param channel channel
* @param band frequency band for wireless ("a" or "bg")
* @returns the frequency represented by the channel of the band, or -1 when the freq is invalid, or 0 when the band is invalid
*/
function utils_wifi_channel_to_freq(channel: number, band: string): number;
/**
* Utility function to find out next/previous Wi-Fi channel for a channel.
* @param channel current channel
* @param direction whether going downward (0 or less) or upward (1 or more)
* @param band frequency band for wireless ("a" or "bg")
* @returns the next channel in the specified direction or 0
*/
function utils_wifi_find_next_channel(channel: number, direction: number, band: string): number;
/**
* Utility function to translate a Wi-Fi frequency to its corresponding channel.
* @param freq frequency
* @returns the channel represented by the frequency or 0
*/
function utils_wifi_freq_to_channel(freq: number): number;
/**
* Utility function to verify Wi-Fi channel validity.
* @param channel channel
* @param band frequency band for wireless ("a" or "bg")
* @returns %TRUE or %FALSE
*/
function utils_wifi_is_channel_valid(channel: number, band: string): boolean;
/**
* Converts `strength` into a 4-character-wide graphical representation of
* strength suitable for printing to stdout.
*
* Previous versions used to take a guess at the terminal type and possibly
* return a wide UTF-8 encoded string. Now it always returns a 7-bit
* clean strings of one to 0 to 4 asterisks. Users that actually need
* the functionality are encouraged to make their implementations instead.
* @param strength the access point strength, from 0 to 100
* @returns the graphical representation of the access point strength
*/
function utils_wifi_strength_bars(strength: number): string;
/**
* Checks if `psk` is a valid WPA PSK
* @param psk a string that might be a WPA PSK
* @returns %TRUE if @psk is a WPA PSK, %FALSE if not
*/
function utils_wpa_psk_valid(psk: string): boolean;
/**
* Load the shared library `plugin_name` and create a new
* #NMVpnEditorPlugin instance via the #NMVpnEditorPluginFactory
* function.
*
* This is similar to nm_vpn_editor_plugin_load_from_file(), but
* it does no validation of the plugin name, instead passes it directly
* to dlopen(). If you have the full path to a plugin file,
* nm_vpn_editor_plugin_load_from_file() is preferred.
* @param plugin_name The name of the shared library to load. This path will be directly passed to dlopen() without further checks.
* @param check_service if not-null, check that the loaded plugin advertises the given service.
* @returns a new plugin instance or %NULL on error.
*/
function vpn_editor_plugin_load(plugin_name: string, check_service: string): VpnEditorPlugin;
/**
* Load the shared library `plugin_name` and create a new
* #NMVpnEditorPlugin instance via the #NMVpnEditorPluginFactory
* function.
*
* If `plugin_name` is not an absolute path name, it assumes the file
* is in the plugin directory of NetworkManager. In any case, the call
* will do certain checks on the file before passing it to dlopen.
* A consequence for that is, that you cannot omit the ".so" suffix
* as you could for nm_vpn_editor_plugin_load().
* @param plugin_name The path or name of the shared library to load. The path must either be an absolute filename to an existing file. Alternatively, it can be the name (without path) of a library in the plugin directory of NetworkManager.
* @param check_service if not-null, check that the loaded plugin advertises the given service.
* @param check_owner if non-negative, check whether the file is owned by UID @check_owner or by root. In this case also check that the file is not writable by anybody else.
* @param check_file optional callback to validate the file prior to loading the shared library.
* @returns a new plugin instance or %NULL on error.
*/
function vpn_editor_plugin_load_from_file(
plugin_name: string,
check_service: string,
check_owner: number,
check_file: UtilsCheckFilePredicate,
): VpnEditorPlugin;
function vpn_plugin_error_quark(): GLib.Quark;
interface KeyfileReadHandler {
(
keyfile: GLib.KeyFile,
connection: Connection,
handler_type: KeyfileHandlerType,
handler_data: KeyfileHandlerData,
): boolean;
}
interface KeyfileWriteHandler {
(
connection: Connection,
keyfile: GLib.KeyFile,
handler_type: KeyfileHandlerType,
handler_data: KeyfileHandlerData,
): boolean;
}
interface SecretAgentOldDeleteSecretsFunc {
(agent: SecretAgentOld, connection: Connection, error: GLib.Error): void;
}
interface SecretAgentOldGetSecretsFunc {
(agent: SecretAgentOld, connection: Connection, secrets: GLib.Variant, error: GLib.Error): void;
}
interface SecretAgentOldSaveSecretsFunc {
(agent: SecretAgentOld, connection: Connection, error: GLib.Error): void;
}
interface SettingClearSecretsWithFlagsFn {
(setting: Setting, secret: string, flags: SettingSecretFlags): boolean;
}
interface SettingValueIterFn {
(setting: Setting, key: string, value: GObject.Value | any, flags: GObject.ParamFlags): void;
}
interface UtilsCheckFilePredicate {
(filename: string, stat?: any | null): boolean;
}
interface UtilsFileSearchInPathsPredicate {
(filename: string): boolean;
}
interface UtilsPredicateStr {
(str: string): boolean;
}
interface VpnIterFunc {
(key: string, value: string): void;
}
/**
* 802.11 access point flags.
*/
/**
* 802.11 access point flags.
*/
export namespace __80211ApFlags {
export const $gtype: GObject.GType<__80211ApFlags>;
}
enum __80211ApFlags {
/**
* access point has no special capabilities
*/
NONE,
/**
* access point requires authentication and
* encryption (usually means WEP)
*/
PRIVACY,
/**
* access point supports some WPS method
*/
WPS,
/**
* access point supports push-button WPS
*/
WPS_PBC,
/**
* access point supports PIN-based WPS
*/
WPS_PIN,
}
/**
* 802.11 access point security and authentication flags. These flags describe
* the current security requirements of an access point as determined from the
* access point's beacon.
*/
/**
* 802.11 access point security and authentication flags. These flags describe
* the current security requirements of an access point as determined from the
* access point's beacon.
*/
export namespace __80211ApSecurityFlags {
export const $gtype: GObject.GType<__80211ApSecurityFlags>;
}
enum __80211ApSecurityFlags {
/**
* the access point has no special security requirements
*/
NONE,
/**
* 40/64-bit WEP is supported for
* pairwise/unicast encryption
*/
PAIR_WEP40,
/**
* 104/128-bit WEP is supported for
* pairwise/unicast encryption
*/
PAIR_WEP104,
/**
* TKIP is supported for pairwise/unicast encryption
*/
PAIR_TKIP,
/**
* AES/CCMP is supported for pairwise/unicast encryption
*/
PAIR_CCMP,
/**
* 40/64-bit WEP is supported for group/broadcast
* encryption
*/
GROUP_WEP40,
/**
* 104/128-bit WEP is supported for
* group/broadcast encryption
*/
GROUP_WEP104,
/**
* TKIP is supported for group/broadcast encryption
*/
GROUP_TKIP,
/**
* AES/CCMP is supported for group/broadcast
* encryption
*/
GROUP_CCMP,
/**
* WPA/RSN Pre-Shared Key encryption is
* supported
*/
KEY_MGMT_PSK,
/**
* 802.1x authentication and key management
* is supported
*/
KEY_MGMT_802_1X,
/**
* WPA/RSN Simultaneous Authentication of Equals is
* supported
*/
KEY_MGMT_SAE,
/**
* WPA/RSN Opportunistic Wireless Encryption is
* supported
*/
KEY_MGMT_OWE,
/**
* WPA/RSN Opportunistic Wireless Encryption
* transition mode is supported. Since: 1.26.
*/
KEY_MGMT_OWE_TM,
/**
* WPA3 Enterprise Suite-B 192 bit mode
* is supported. Since: 1.30.
*/
KEY_MGMT_EAP_SUITE_B_192,
}
/**
* Flags describing the current activation state.
*/
/**
* Flags describing the current activation state.
*/
export namespace ActivationStateFlags {
export const $gtype: GObject.GType;
}
enum ActivationStateFlags {
/**
* an alias for numeric zero, no flags set.
*/
NONE,
/**
* the device is a controller.
*/
IS_CONTROLLER,
/**
* the device is a port.
*/
IS_PORT,
/**
* layer2 is activated and ready.
*/
LAYER2_READY,
/**
* IPv4 setting is completed.
*/
IP4_READY,
/**
* IPv6 setting is completed.
*/
IP6_READY,
/**
* The controller has any port devices attached.
* This only makes sense if the device is a controller.
*/
CONTROLLER_HAS_PORTS,
/**
* the lifetime
* of the activation is bound to the visibility of the connection profile,
* which in turn depends on "connection.permissions" and whether a session
* for the user exists. Since: 1.16.
*/
LIFETIME_BOUND_TO_PROFILE_VISIBILITY,
/**
* the active connection was generated to
* represent an external configuration of a networking device. Since: 1.26.
*/
EXTERNAL,
}
/**
* #NMBluetoothCapabilities values indicate the usable capabilities of a
* Bluetooth device.
*/
/**
* #NMBluetoothCapabilities values indicate the usable capabilities of a
* Bluetooth device.
*/
export namespace BluetoothCapabilities {
export const $gtype: GObject.GType;
}
enum BluetoothCapabilities {
/**
* device has no usable capabilities
*/
NONE,
/**
* device provides Dial-Up Networking capability
*/
DUN,
/**
* device provides Network Access Point capability
*/
NAP,
}
/**
* The flags for CheckpointCreate call
*/
/**
* The flags for CheckpointCreate call
*/
export namespace CheckpointCreateFlags {
export const $gtype: GObject.GType;
}
enum CheckpointCreateFlags {
/**
* no flags
*/
NONE,
/**
* when creating
* a new checkpoint, destroy all existing ones.
*/
DESTROY_ALL,
/**
* upon rollback,
* delete any new connection added after the checkpoint. Since: 1.6.
*/
DELETE_NEW_CONNECTIONS,
/**
* upon rollback,
* disconnect any new device appeared after the checkpoint. Since: 1.6.
*/
DISCONNECT_NEW_DEVICES,
/**
* by default, creating
* a checkpoint fails if there are already existing checkpoints that
* reference the same devices. With this flag, creation of such
* checkpoints is allowed, however, if an older checkpoint
* that references overlapping devices gets rolled back, it will
* automatically destroy this checkpoint during rollback. This
* allows to create several overlapping checkpoints in parallel,
* and rollback to them at will. With the special case that
* rolling back to an older checkpoint will invalidate all
* overlapping younger checkpoints. This opts-in that the
* checkpoint can be automatically destroyed by the rollback
* of an older checkpoint. Since: 1.12.
*/
ALLOW_OVERLAPPING,
/**
* during rollback,
* by default externally added ports attached to bridge devices are preserved.
* With this flag, the rollback detaches all external ports.
* This only has an effect for bridge ports. Before 1.38, this was the default
* behavior. Since: 1.38.
*/
NO_PRESERVE_EXTERNAL_PORTS,
/**
* during rollback,
* by default changes to global DNS via D-BUS interface are preserved.
* With this flag, the rollback reverts the global DNS changes made via D-Bus
* interface. Global DNS defined in [global-dns] section of
* NetworkManager.conf is not impacted by this flag. Since: 1.48.
*/
TRACK_INTERNAL_GLOBAL_DNS,
}
export namespace ClientInstanceFlags {
export const $gtype: GObject.GType;
}
enum ClientInstanceFlags {
/**
* special value to indicate no flags.
*/
NONE,
/**
* by default, NMClient
* will fetch the permissions via "GetPermissions" and refetch them when
* "CheckPermissions" signal gets received. By setting this flag, this behavior
* can be disabled. You can toggle this flag to enable and disable automatic
* fetching of the permissions. Watch also nm_client_get_permissions_state()
* to know whether the permissions are up to date.
*/
NO_AUTO_FETCH_PERMISSIONS,
/**
* as #NMClient is an GInitable
* and GAsyncInitable, nm_client_get_instance_flags() returns this flag
* once initialization completed with success. This flag cannot be set
* as NM_CLIENT_INSTANCE_FLAGS property. Since: 1.42.
*/
INITIALIZED_GOOD,
/**
* like `NM_CLIENT_INSTANCE_FLAGS_INITIALIZED_GOOD`
* indicates that the instance completed initialization with failure. In that
* case the instance is unusable. Since: 1.42.
*/
INITIALIZED_BAD,
}
/**
* These flags determine which properties are serialized when calling
* nm_connection_to_dbus().
*/
/**
* These flags determine which properties are serialized when calling
* nm_connection_to_dbus().
*/
export namespace ConnectionSerializationFlags {
export const $gtype: GObject.GType;
}
enum ConnectionSerializationFlags {
/**
* serialize all properties (including secrets)
*/
ALL,
/**
* serialize properties that are
* not secrets. Since 1.32.
*/
WITH_NON_SECRET,
/**
* this is a deprecated alias for
* `NM_CONNECTION_SERIALIZE_WITH_NON_SECRET`.
*/
NO_SECRETS,
/**
* serialize all secrets. This flag is
* ignored if any of `NM_CONNECTION_SERIALIZE_WITH_SECRETS_AGENT_OWNED,`
* `NM_CONNECTION_SERIALIZE_WITH_SECRETS_SYSTEM_OWNED` or
* `NM_CONNECTION_SERIALIZE_WITH_SECRETS_NOT_SAVED` is set. Since 1.32.
*/
WITH_SECRETS,
/**
* a deprecated alias for
* `NM_CONNECTION_SERIALIZE_WITH_SECRETS`.
*/
ONLY_SECRETS,
/**
* serialize agent-owned
* secrets. Since: 1.20.
*/
WITH_SECRETS_AGENT_OWNED,
/**
* serialize system-owned
* secrets. Since: 1.32.
*/
WITH_SECRETS_SYSTEM_OWNED,
/**
* serialize secrets that
* are marked as never saved. Since: 1.32.
*/
WITH_SECRETS_NOT_SAVED,
}
/**
* General device capability flags.
*/
/**
* General device capability flags.
*/
export namespace DeviceCapabilities {
export const $gtype: GObject.GType;
}
enum DeviceCapabilities {
/**
* device has no special capabilities
*/
NONE,
/**
* NetworkManager supports this device
*/
NM_SUPPORTED,
/**
* this device can indicate carrier status
*/
CARRIER_DETECT,
/**
* this device is a software device
*/
IS_SOFTWARE,
/**
* this device supports single-root I/O virtualization
*/
SRIOV,
}
/**
* Flags for a network interface.
*/
/**
* Flags for a network interface.
*/
export namespace DeviceInterfaceFlags {
export const $gtype: GObject.GType;
}
enum DeviceInterfaceFlags {
/**
* the interface is enabled from the
* administrative point of view. Corresponds to kernel IFF_UP.
*/
UP,
/**
* the physical link is up. Corresponds
* to kernel IFF_LOWER_UP.
*/
LOWER_UP,
/**
* receive all packets. Corresponds to
* kernel IFF_PROMISC. Since: 1.32.
*/
PROMISC,
/**
* the interface has carrier. In most
* cases this is equal to the value of `NM_DEVICE_INTERFACE_FLAG_LOWER_UP`.
* However some devices have a non-standard carrier detection mechanism.
*/
CARRIER,
/**
* the flag to indicate device
* LLDP status. Since: 1.32.
*/
LLDP_CLIENT_ENABLED,
}
/**
* #NMDeviceModemCapabilities values indicate the generic radio access
* technology families a modem device supports. For more information on the
* specific access technologies the device supports use the ModemManager D-Bus
* API.
*/
/**
* #NMDeviceModemCapabilities values indicate the generic radio access
* technology families a modem device supports. For more information on the
* specific access technologies the device supports use the ModemManager D-Bus
* API.
*/
export namespace DeviceModemCapabilities {
export const $gtype: GObject.GType;
}
enum DeviceModemCapabilities {
/**
* modem has no usable capabilities
*/
NONE,
/**
* modem uses the analog wired telephone
* network and is not a wireless/cellular device
*/
POTS,
/**
* modem supports at least one of CDMA
* 1xRTT, EVDO revision 0, EVDO revision A, or EVDO revision B
*/
CDMA_EVDO,
/**
* modem supports at least one of GSM,
* GPRS, EDGE, UMTS, HSDPA, HSUPA, or HSPA+ packet switched data capability
*/
GSM_UMTS,
/**
* modem has LTE data capability
*/
LTE,
/**
* modem has 5GNR data capability. Since: 1.36.
*/
'5GNR',
}
/**
* Flags for the Reapply() D-Bus call of a device and
* nm_device_reapply_async().
*/
/**
* Flags for the Reapply() D-Bus call of a device and
* nm_device_reapply_async().
*/
export namespace DeviceReapplyFlags {
export const $gtype: GObject.GType;
}
enum DeviceReapplyFlags {
/**
* no flag set.
*/
NONE,
/**
* during reapply,
* preserve external IP addresses and routes.
*/
PRESERVE_EXTERNAL_IP,
}
/**
* 802.11 specific device encryption and authentication capabilities.
*/
/**
* 802.11 specific device encryption and authentication capabilities.
*/
export namespace DeviceWifiCapabilities {
export const $gtype: GObject.GType;
}
enum DeviceWifiCapabilities {
/**
* device has no encryption/authentication capabilities
*/
NONE,
/**
* device supports 40/64-bit WEP encryption
*/
CIPHER_WEP40,
/**
* device supports 104/128-bit WEP encryption
*/
CIPHER_WEP104,
/**
* device supports TKIP encryption
*/
CIPHER_TKIP,
/**
* device supports AES/CCMP encryption
*/
CIPHER_CCMP,
/**
* device supports WPA1 authentication
*/
WPA,
/**
* device supports WPA2/RSN authentication
*/
RSN,
/**
* device supports Access Point mode
*/
AP,
/**
* device supports Ad-Hoc mode
*/
ADHOC,
/**
* device reports frequency capabilities
*/
FREQ_VALID,
/**
* device supports 2.4GHz frequencies
*/
FREQ_2GHZ,
/**
* device supports 5GHz frequencies
*/
FREQ_5GHZ,
/**
* device supports 6GHz frequencies. Since: 1.46.
*/
FREQ_6GHZ,
/**
* device supports acting as a mesh point. Since: 1.20.
*/
MESH,
/**
* device supports WPA2/RSN in an IBSS network. Since: 1.22.
*/
IBSS_RSN,
}
/**
* #NMDhcpHostnameFlags describe flags related to the DHCP hostname and
* FQDN.
*/
/**
* #NMDhcpHostnameFlags describe flags related to the DHCP hostname and
* FQDN.
*/
export namespace DhcpHostnameFlags {
export const $gtype: GObject.GType;
}
enum DhcpHostnameFlags {
/**
* no flag set. The default value from
* Networkmanager global configuration is used. If such value is unset
* or still zero, the DHCP request will use standard FQDN flags, i.e.
* %NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE and
* %NM_DHCP_HOSTNAME_FLAG_FQDN_ENCODED for IPv4 and
* %NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE for IPv6.
*/
NONE,
/**
* whether the server should
* do the A RR (FQDN-to-address) DNS updates.
*/
FQDN_SERV_UPDATE,
/**
* if set, the FQDN is encoded
* using canonical wire format. Otherwise it uses the deprecated
* ASCII encoding. This flag is allowed only for DHCPv4.
*/
FQDN_ENCODED,
/**
* when not set, request the
* server to perform updates (the PTR RR and possibly the A RR
* based on the %NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE flag). If
* this is set, the %NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE flag
* should be cleared.
*/
FQDN_NO_UPDATE,
/**
* when set, no FQDN flags are
* sent in the DHCP FQDN option. When cleared and all other FQDN
* flags are zero, standard FQDN flags are sent. This flag is
* incompatible with any other FQDN flag.
*/
FQDN_CLEAR_FLAGS,
}
/**
* Compare flags for nm_ip_address_cmp_full().
*/
/**
* Compare flags for nm_ip_address_cmp_full().
*/
export namespace IPAddressCmpFlags {
export const $gtype: GObject.GType;
}
enum IPAddressCmpFlags {
/**
* no flags.
*/
NONE,
/**
* when comparing two addresses,
* also consider their attributes. Warning: note that attributes are GVariants
* and they don't have a total order. In other words, if the address differs only
* by their attributes, the returned compare order is not total. In that case,
* the return value merely indicates equality (zero) or inequality.
*/
WITH_ATTRS,
}
export namespace IPRoutingRuleAsStringFlags {
export const $gtype: GObject.GType;
}
enum IPRoutingRuleAsStringFlags {
/**
* no flags selected.
*/
NONE,
/**
* whether to allow parsing
* IPv4 addresses.
*/
AF_INET,
/**
* whether to allow parsing
* IPv6 addresses. If both `NM_IP_ROUTING_RULE_AS_STRING_FLAGS_AF_INET` and
* `NM_IP_ROUTING_RULE_AS_STRING_FLAGS_AF_INET6` are unset, it's the same
* as setting them both.
*/
AF_INET6,
/**
* if set, ensure that the
* rule verfies or fail.
*/
VALIDATE,
}
/**
* IP tunnel flags.
*/
/**
* IP tunnel flags.
*/
export namespace IPTunnelFlags {
export const $gtype: GObject.GType;
}
enum IPTunnelFlags {
/**
* no flag
*/
NONE,
/**
* don't add encapsulation limit
* if one isn't present in inner packet
*/
IP6_IGN_ENCAP_LIMIT,
/**
* copy the traffic class field
* from the inner packet
*/
IP6_USE_ORIG_TCLASS,
/**
* copy the flowlabel from the
* inner packet
*/
IP6_USE_ORIG_FLOWLABEL,
/**
* used for Mobile IPv6
*/
IP6_MIP6_DEV,
/**
* copy DSCP from the outer packet
*/
IP6_RCV_DSCP_COPY,
/**
* copy fwmark from inner packet
*/
IP6_USE_ORIG_FWMARK,
}
/**
* Flags for customizing nm_keyfile_read() and nm_keyfile_write().
*
* Currently no flags are implemented.
*/
/**
* Flags for customizing nm_keyfile_read() and nm_keyfile_write().
*
* Currently no flags are implemented.
*/
export namespace KeyfileHandlerFlags {
export const $gtype: GObject.GType;
}
enum KeyfileHandlerFlags {
/**
* no flags set.
*/
NONE,
}
/**
* Flags for the manager Reload() call.
*/
/**
* Flags for the manager Reload() call.
*/
export namespace ManagerReloadFlags {
export const $gtype: GObject.GType;
}
enum ManagerReloadFlags {
/**
* reload the NetworkManager.conf configuration
* from disk. Note that this does not include connections, which can be
* reloaded via Setting's ReloadConnections().
*/
CONF,
/**
* update DNS configuration, which usually
* involves writing /etc/resolv.conf anew.
*/
DNS_RC,
/**
* means to restart the DNS plugin. This
* is for example useful when using dnsmasq plugin, which uses additional
* configuration in /etc/NetworkManager/dnsmasq.d. If you edit those files,
* you can restart the DNS plugin. This action shortly interrupts name
* resolution.
*/
DNS_FULL,
}
export namespace MptcpFlags {
export const $gtype: GObject.GType;
}
enum MptcpFlags {
/**
* The default, meaning that no MPTCP flags are set.
*/
NONE,
/**
* don't configure MPTCP endpoints on the device.
*/
DISABLED,
/**
* MPTCP is enabled and endpoints will be configured.
* This flag is implied if any of the other flags indicate that
* MPTCP is enabled and therefore in most cases unnecessary.
* Note that if "/proc/sys/net/mptcp/enabled" sysctl is disabled, MPTCP
* handling is disabled despite this flag. This can be overruled with the
* "also-without-sysctl" flag.
* Note that by default interfaces that don't have a default route are
* excluded from having MPTCP endpoints configured. This can be overruled
* with the "also-without-default-route" and this affects endpoints
* per address family.
*/
ENABLED,
/**
* even if MPTCP handling is enabled
* via the "enabled" flag, it is ignored unless "/proc/sys/net/mptcp/enabled"
* is on. With this flag, MPTCP endpoints will be configured regardless
* of the sysctl setting.
*/
ALSO_WITHOUT_SYSCTL,
/**
* even if MPTCP handling is enabled
* via the "enabled" flag, it is ignored per-address family unless NetworkManager
* configures a default route. With this flag, NetworkManager will also configure
* MPTCP endpoints if there is no default route. This takes effect per-address
* family.
*/
ALSO_WITHOUT_DEFAULT_ROUTE,
/**
* Flag for the MPTCP endpoint. The endpoint will be
* announced/signaled to each peer via an MPTCP ADD_ADDR sub-option.
*/
SIGNAL,
/**
* Flag for the MPTCP endpoint. If additional subflow creation
* is allowed by the MPTCP limits, the MPTCP path manager will try to create an
* additional subflow using this endpoint as the source address after the MPTCP connection
* is established.
*/
SUBFLOW,
/**
* Flag for the MPTCP endpoint. If this is a subflow endpoint, the
* subflows created using this endpoint will have the backup flag set during the connection
* process. This flag instructs the peer to only send data on a given subflow when all
* non-backup subflows are unavailable. This does not affect outgoing data,
* where subflow priority is determined by the backup/non-backup flag received
* from the peer
*/
BACKUP,
/**
* Flag for the MPTCP endpoint. If this is a subflow endpoint and additional
* subflow creation is allowed by the MPTCP limits, the MPTCP path manager will try to create an
* additional subflow for each known peer address, using this endpoint as the source address.
* This will occur after the MPTCP connection is established. If the peer did not announce
* any additional addresses using the MPTCP ADD_ADDR sub-option, this will behave the same
* as a plain subflow endpoint. When the peer does announce addresses, each received ADD_ADDR
* sub-option will trigger creation of an additional subflow to generate a full mesh topology.
*/
FULLMESH,
}
/**
* Flags related to radio interfaces.
*/
/**
* Flags related to radio interfaces.
*/
export namespace RadioFlags {
export const $gtype: GObject.GType;
}
enum RadioFlags {
/**
* an alias for numeric zero, no flags set.
*/
NONE,
/**
* A Wireless LAN device or rfkill switch
* is detected in the system.
*/
WLAN_AVAILABLE,
/**
* A Wireless WAN device or rfkill switch
* is detected in the system.
*/
WWAN_AVAILABLE,
}
/**
* #NMSecretAgentCapabilities indicate various capabilities of the agent.
*/
/**
* #NMSecretAgentCapabilities indicate various capabilities of the agent.
*/
export namespace SecretAgentCapabilities {
export const $gtype: GObject.GType;
}
enum SecretAgentCapabilities {
/**
* the agent supports no special capabilities
*/
NONE,
/**
* the agent supports passing hints to
* VPN plugin authentication dialogs.
*/
VPN_HINTS,
/**
* bounds checking value; should not be used.
*/
LAST,
}
/**
* #NMSecretAgentGetSecretsFlags values modify the behavior of a GetSecrets request.
*/
/**
* #NMSecretAgentGetSecretsFlags values modify the behavior of a GetSecrets request.
*/
export namespace SecretAgentGetSecretsFlags {
export const $gtype: GObject.GType;
}
enum SecretAgentGetSecretsFlags {
/**
* no special behavior; by default no
* user interaction is allowed and requests for secrets are fulfilled from
* persistent storage, or if no secrets are available an error is returned.
*/
NONE,
/**
* allows the request to
* interact with the user, possibly prompting via UI for secrets if any are
* required, or if none are found in persistent storage.
*/
ALLOW_INTERACTION,
/**
* explicitly prompt for new
* secrets from the user. This flag signals that NetworkManager thinks any
* existing secrets are invalid or wrong. This flag implies that interaction
* is allowed.
*/
REQUEST_NEW,
/**
* set if the request was
* initiated by user-requested action via the D-Bus interface, as opposed to
* automatically initiated by NetworkManager in response to (for example) scan
* results or carrier changes.
*/
USER_REQUESTED,
/**
* indicates that WPS enrollment
* is active with PBC method. The agent may suggest that the user pushes a button
* on the router instead of supplying a PSK.
*/
WPS_PBC_ACTIVE,
/**
* Internal flag, not part of
* the D-Bus API.
*/
ONLY_SYSTEM,
/**
* Internal flag, not part of
* the D-Bus API.
*/
NO_ERRORS,
}
/**
* #NMSetting8021xAuthFlags values indicate which authentication settings
* should be used.
*
* Before 1.22, this was wrongly marked as a enum and not as a flags
* type.
*/
/**
* #NMSetting8021xAuthFlags values indicate which authentication settings
* should be used.
*
* Before 1.22, this was wrongly marked as a enum and not as a flags
* type.
*/
export namespace Setting8021xAuthFlags {
export const $gtype: GObject.GType;
}
enum Setting8021xAuthFlags {
/**
* No flags
*/
NONE,
/**
* Disable TLSv1.0
*/
TLS_1_0_DISABLE,
/**
* Disable TLSv1.1
*/
TLS_1_1_DISABLE,
/**
* Disable TLSv1.2
*/
TLS_1_2_DISABLE,
/**
* Disable TLS time checks. Since 1.42.
*/
TLS_DISABLE_TIME_CHECKS,
/**
* Disable TLSv1.3. Since 1.42.
*/
TLS_1_3_DISABLE,
/**
* Enable TLSv1.0. Since 1.42.
*/
TLS_1_0_ENABLE,
/**
* Enable TLSv1.1. Since 1.42.
*/
TLS_1_1_ENABLE,
/**
* Enable TLSv1.2. Since 1.42.
*/
TLS_1_2_ENABLE,
/**
* Enable TLSv1.3. Since 1.42.
*/
TLS_1_3_ENABLE,
/**
* All supported flags
*/
ALL,
}
/**
* DCB feature flags.
*/
/**
* DCB feature flags.
*/
export namespace SettingDcbFlags {
export const $gtype: GObject.GType;
}
enum SettingDcbFlags {
/**
* no flag
*/
NONE,
/**
* the feature is enabled
*/
ENABLE,
/**
* the feature is advertised
*/
ADVERTISE,
/**
* the feature is willing to change based on
* peer configuration advertisements
*/
WILLING,
}
/**
* These flags modify the ethtool FEC(Forward Error Correction) mode.
*/
/**
* These flags modify the ethtool FEC(Forward Error Correction) mode.
*/
export namespace SettingEthtoolFecMode {
export const $gtype: GObject.GType;
}
enum SettingEthtoolFecMode {
/**
* Select default/best FEC mode automatically.
*/
AUTO,
/**
* No FEC mode.
*/
OFF,
/**
* Reed-Solomon FEC Mode.
*/
RS,
/**
* Base-R/Reed-Solomon FEC Mode.
*/
BASER,
/**
* Low Latency Reed Solomon FEC Mode.
*/
LLRS,
}
/**
* These flags indicate specific behavior related to handling of a secret. Each
* secret has a corresponding set of these flags which indicate how the secret
* is to be stored and/or requested when it is needed.
*/
/**
* These flags indicate specific behavior related to handling of a secret. Each
* secret has a corresponding set of these flags which indicate how the secret
* is to be stored and/or requested when it is needed.
*/
export namespace SettingSecretFlags {
export const $gtype: GObject.GType;
}
enum SettingSecretFlags {
/**
* the system is responsible for providing and
* storing this secret (default)
*/
NONE,
/**
* a user secret agent is responsible
* for providing and storing this secret; when it is required agents will be
* asked to retrieve it
*/
AGENT_OWNED,
/**
* this secret should not be saved, but
* should be requested from the user each time it is needed
*/
NOT_SAVED,
/**
* in situations where it cannot be
* automatically determined that the secret is required (some VPNs and PPP
* providers don't require all secrets) this flag indicates that the specific
* secret is not required
*/
NOT_REQUIRED,
}
/**
* Options for #NMSettingWired:wake-on-lan. Note that not all options
* are supported by all devices.
*/
/**
* Options for #NMSettingWired:wake-on-lan. Note that not all options
* are supported by all devices.
*/
export namespace SettingWiredWakeOnLan {
export const $gtype: GObject.GType;
}
enum SettingWiredWakeOnLan {
/**
* Wake on PHY activity
*/
PHY,
/**
* Wake on unicast messages
*/
UNICAST,
/**
* Wake on multicast messages
*/
MULTICAST,
/**
* Wake on broadcast messages
*/
BROADCAST,
/**
* Wake on ARP
*/
ARP,
/**
* Wake on magic packet
*/
MAGIC,
/**
* Use the default value
*/
DEFAULT,
/**
* Don't change configured settings
*/
IGNORE,
}
/**
* Configure the use of WPS by a connection while it activates.
*
* Note: prior to 1.16, this was a GEnum type instead of a GFlags type
* although, with the same numeric values.
*/
/**
* Configure the use of WPS by a connection while it activates.
*
* Note: prior to 1.16, this was a GEnum type instead of a GFlags type
* although, with the same numeric values.
*/
export namespace SettingWirelessSecurityWpsMethod {
export const $gtype: GObject.GType;
}
enum SettingWirelessSecurityWpsMethod {
/**
* Attempt whichever method AP supports
*/
DEFAULT,
/**
* WPS can not be used.
*/
DISABLED,
/**
* Use WPS, any method
*/
AUTO,
/**
* use WPS push-button method
*/
PBC,
/**
* use PIN method
*/
PIN,
}
/**
* Options for #NMSettingWireless:wake-on-wlan. Note that not all options
* are supported by all devices.
*/
/**
* Options for #NMSettingWireless:wake-on-wlan. Note that not all options
* are supported by all devices.
*/
export namespace SettingWirelessWakeOnWLan {
export const $gtype: GObject.GType;
}
enum SettingWirelessWakeOnWLan {
/**
* Wake on any activity
*/
ANY,
/**
* Wake on disconnect
*/
DISCONNECT,
/**
* Wake on magic packet
*/
MAGIC,
/**
* Wake on GTK rekey failure
*/
GTK_REKEY_FAILURE,
/**
* Wake on EAP identity request
*/
EAP_IDENTITY_REQUEST,
/**
* Wake on 4way handshake
*/
'4WAY_HANDSHAKE',
/**
* Wake on rfkill release
*/
RFKILL_RELEASE,
TCP,
/**
* Wake on all events. This does not
* include the exclusive flags `NM_SETTING_WIRELESS_WAKE_ON_WLAN_DEFAULT` or
* `NM_SETTING_WIRELESS_WAKE_ON_WLAN_IGNORE`.
*/
ALL,
/**
* Use the default value
*/
DEFAULT,
/**
* Don't change configured settings
*/
IGNORE,
}
/**
* Numeric flags for the "flags" argument of AddConnection2() D-Bus API.
*/
/**
* Numeric flags for the "flags" argument of AddConnection2() D-Bus API.
*/
export namespace SettingsAddConnection2Flags {
export const $gtype: GObject.GType;
}
enum SettingsAddConnection2Flags {
/**
* an alias for numeric zero, no flags set.
*/
NONE,
/**
* to persist the connection to disk.
*/
TO_DISK,
/**
* to make the connection in-memory only.
*/
IN_MEMORY,
/**
* usually, when the connection
* has autoconnect enabled and gets added, it becomes eligible to autoconnect
* right away. Setting this flag, disables autoconnect until the connection
* is manually activated.
*/
BLOCK_AUTOCONNECT,
}
/**
* Flags describing the current activation state.
*/
/**
* Flags describing the current activation state.
*/
export namespace SettingsConnectionFlags {
export const $gtype: GObject.GType;
}
enum SettingsConnectionFlags {
/**
* an alias for numeric zero, no flags set.
*/
NONE,
/**
* the connection is not saved to disk.
* That either means, that the connection is in-memory only and currently
* is not backed by a file. Or, that the connection is backed by a file,
* but has modifications in-memory that were not persisted to disk.
*/
UNSAVED,
/**
* A connection is "nm-generated" if
* it was generated by NetworkManger. If the connection gets modified or saved
* by the user, the flag gets cleared. A nm-generated is also unsaved
* and has no backing file as it is in-memory only.
*/
NM_GENERATED,
/**
* The connection will be deleted
* when it disconnects. That is for in-memory connections (unsaved), which are
* currently active but deleted on disconnect. Volatile connections are
* always unsaved, but they are also no backing file on disk and are entirely
* in-memory only.
*/
VOLATILE,
/**
* the profile was generated to represent
* an external configuration of a networking device. Since: 1.26.
*/
EXTERNAL,
}
export namespace SettingsUpdate2Flags {
export const $gtype: GObject.GType;
}
enum SettingsUpdate2Flags {
/**
* an alias for numeric zero, no flags set.
*/
NONE,
/**
* to persist the connection to disk.
*/
TO_DISK,
/**
* makes the profile in-memory.
* Note that such profiles are stored in keyfile format under /run.
* If the file is already in-memory, the file in /run is updated in-place.
* Otherwise, the previous storage for the profile is left unchanged
* on disk, and the in-memory copy shadows it.
* Note that the original filename of the previous persistent storage (if any)
* is remembered. That means, when later persisting the profile again to disk,
* the file on disk will be overwritten again.
* Likewise, when finally deleting the profile, both the storage from /run
* and persistent storage are deleted (or if the persistent storage does not
* allow deletion, and nmmeta file is written to mark the UUID as deleted).
*/
IN_MEMORY,
/**
* this is almost the same
* as %NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY, with one difference: when later deleting
* the profile, the original profile will not be deleted. Instead a nmmeta
* file is written to /run to indicate that the profile is gone.
* Note that if such a nmmeta tombstone file exists and hides a file in persistent
* storage, then when re-adding the profile with the same UUID, then the original
* storage is taken over again.
*/
IN_MEMORY_DETACHED,
/**
* this is like %NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY,
* but if the connection has a corresponding file on persistent storage, the file
* will be deleted right away. If the profile is later again persisted to disk,
* a new, unused filename will be chosen.
*/
IN_MEMORY_ONLY,
/**
* This can be specified with either
* %NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY, %NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY_DETACHED
* or %NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY_ONLY.
* After making the connection in-memory only, the connection is marked
* as volatile. That means, if the connection is currently not active
* it will be deleted right away. Otherwise, it is marked to for deletion
* once the connection deactivates. A volatile connection cannot autoactivate
* again (because it's about to be deleted), but a manual activation will
* clear the volatile flag.
*/
VOLATILE,
/**
* usually, when the connection
* has autoconnect enabled and is modified, it becomes eligible to autoconnect
* right away. Setting this flag, disables autoconnect until the connection
* is manually activated.
*/
BLOCK_AUTOCONNECT,
/**
* when a profile gets modified that is
* currently active, then these changes don't take effect for the active
* device unless the profile gets reactivated or the configuration reapplied.
* There are two exceptions: by default "connection.zone" and "connection.metered"
* properties take effect immediately. Specify this flag to prevent these
* properties to take effect, so that the change is restricted to modify
* the profile. Since: 1.20.
*/
NO_REAPPLY,
}
export namespace TeamLinkWatcherArpPingFlags {
export const $gtype: GObject.GType;
}
enum TeamLinkWatcherArpPingFlags {
/**
* the arp_ping link watcher
* option 'validate_active' is enabled (set to true).
*/
VALIDATE_ACTIVE,
/**
* the arp_ping link watcher
* option 'validate_inactive' is enabled (set to true).
*/
VALIDATE_INACTIVE,
/**
* the arp_ping link watcher option
* 'send_always' is enabled (set to true).
*/
SEND_ALWAYS,
}
/**
* #NMVlanFlags values control the behavior of the VLAN interface.
*/
/**
* #NMVlanFlags values control the behavior of the VLAN interface.
*/
export namespace VlanFlags {
export const $gtype: GObject.GType;
}
enum VlanFlags {
/**
* indicates that this interface should reorder
* outgoing packet headers to look more like a non-VLAN Ethernet interface
*/
REORDER_HEADERS,
/**
* indicates that this interface should use GVRP to register
* itself with its switch
*/
GVRP,
/**
* indicates that this interface's operating
* state is tied to the underlying network interface but other details
* (like routing) are not.
*/
LOOSE_BINDING,
/**
* indicates that this interface should use MVRP to register
* itself with its switch
*/
MVRP,
}
/**
* Flags that indicate certain capabilities of the plugin to editor programs.
*/
/**
* Flags that indicate certain capabilities of the plugin to editor programs.
*/
export namespace VpnEditorPluginCapability {
export const $gtype: GObject.GType;
}
enum VpnEditorPluginCapability {
/**
* Unknown or no capability.
*/
NONE,
/**
* The plugin can import new connections.
*/
IMPORT,
/**
* The plugin can export connections.
*/
EXPORT,
/**
* The plugin supports IPv6 addressing.
*/
IPV6,
/**
* The GUI editor plugin is not available. Since: 1.52.
*/
NO_EDITOR,
}
namespace AccessPoint {
// Constructor properties interface
interface ConstructorProps extends Object.ConstructorProps {
bandwidth: number;
bssid: string;
flags: __80211ApFlags;
frequency: number;
hw_address: string;
hwAddress: string;
last_seen: number;
lastSeen: number;
max_bitrate: number;
maxBitrate: number;
mode: __80211Mode;
rsn_flags: __80211ApSecurityFlags;
rsnFlags: __80211ApSecurityFlags;
ssid: GLib.Bytes;
strength: number;
wpa_flags: __80211ApSecurityFlags;
wpaFlags: __80211ApSecurityFlags;
}
}
class AccessPoint extends Object {
static $gtype: GObject.GType;
// Properties
/**
* The channel bandwidth announced by the AP in MHz.
*/
get bandwidth(): number;
/**
* The BSSID of the access point.
*/
get bssid(): string;
/**
* The flags of the access point.
*/
get flags(): __80211ApFlags;
/**
* The frequency of the access point.
*/
get frequency(): number;
/**
* Alias for #NMAccessPoint:bssid.
*/
get hw_address(): string;
/**
* Alias for #NMAccessPoint:bssid.
*/
get hwAddress(): string;
/**
* The timestamp (in CLOCK_BOOTTIME seconds) for the last time the
* access point was found in scan results. A value of -1 means the
* access point has not been found in a scan.
*/
get last_seen(): number;
/**
* The timestamp (in CLOCK_BOOTTIME seconds) for the last time the
* access point was found in scan results. A value of -1 means the
* access point has not been found in a scan.
*/
get lastSeen(): number;
/**
* The maximum bit rate of the access point in kbit/s.
*/
get max_bitrate(): number;
/**
* The maximum bit rate of the access point in kbit/s.
*/
get maxBitrate(): number;
/**
* The mode of the access point; either "infrastructure" (a central
* coordinator of the wireless network allowing clients to connect) or
* "ad-hoc" (a network with no central controller).
*/
get mode(): __80211Mode;
/**
* The RSN flags of the access point.
*/
get rsn_flags(): __80211ApSecurityFlags;
/**
* The RSN flags of the access point.
*/
get rsnFlags(): __80211ApSecurityFlags;
/**
* The SSID of the access point, or %NULL if it is not known.
*/
get ssid(): GLib.Bytes;
/**
* The current signal strength of the access point.
*/
get strength(): number;
/**
* The WPA flags of the access point.
*/
get wpa_flags(): __80211ApSecurityFlags;
/**
* The WPA flags of the access point.
*/
get wpaFlags(): __80211ApSecurityFlags;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
/**
* Validates a given connection against a given Wi-Fi access point to ensure that
* the connection may be activated with that AP. The connection must match the
* `ap'`s SSID, (if given) BSSID, and other attributes like security settings,
* channel, band, etc.
* @param connection an #NMConnection to validate against @ap
* @returns %TRUE if the connection may be activated with this Wi-Fi AP, %FALSE if it cannot be.
*/
connection_valid(connection: Connection): boolean;
/**
* Filters a given array of connections for a given #NMAccessPoint object and
* returns connections which may be activated with the access point. Any
* returned connections will match the `ap'`s SSID and (if given) BSSID and
* other attributes like security settings, channel, etc.
*
* To obtain the list of connections that are compatible with this access point,
* use nm_client_get_connections() and then filter the returned list for a given
* #NMDevice using nm_device_filter_connections() and finally filter that list
* with this function.
* @param connections an array of #NMConnections to filter
* @returns an array of #NMConnections that could be activated with the given @ap. The array should be freed with g_ptr_array_unref() when it is no longer required. WARNING: the transfer annotation for this function may not work correctly with bindings. See https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/305. You can filter the list yourself with nm_access_point_connection_valid().
*/
filter_connections(connections: Connection[]): Connection[];
/**
* Gets the bandwidth advertised by the access point in MHz.
* @returns the advertised bandwidth (MHz)
*/
get_bandwidth(): number;
/**
* Gets the Basic Service Set ID (BSSID) of the Wi-Fi access point.
* @returns the BSSID of the access point. This is an internal string and must not be modified or freed.
*/
get_bssid(): string;
/**
* Gets the flags of the access point.
* @returns the flags
*/
get_flags(): __80211ApFlags;
/**
* Gets the frequency of the access point in MHz.
* @returns the frequency in MHz
*/
get_frequency(): number;
/**
* Returns the timestamp (in CLOCK_BOOTTIME seconds) for the last time the
* access point was found in scan results. A value of -1 means the access
* point has not been found in a scan.
* @returns the last seen time in seconds
*/
get_last_seen(): number;
/**
* Gets the maximum bit rate of the access point in kbit/s.
* @returns the maximum bit rate (kbit/s)
*/
get_max_bitrate(): number;
/**
* Gets the mode of the access point.
* @returns the mode
*/
get_mode(): __80211Mode;
/**
* Gets the RSN (Robust Secure Network, ie WPA version 2) flags of the access
* point.
* @returns the RSN flags
*/
get_rsn_flags(): __80211ApSecurityFlags;
/**
* Gets the SSID of the access point.
* @returns the #GBytes containing the SSID, or %NULL if the SSID is unknown.
*/
get_ssid(): GLib.Bytes;
/**
* Gets the current signal strength of the access point as a percentage.
* @returns the signal strength (0 to 100)
*/
get_strength(): number;
/**
* Gets the WPA (version 1) flags of the access point.
* @returns the WPA flags
*/
get_wpa_flags(): __80211ApSecurityFlags;
}
namespace ActiveConnection {
// Signal callback interfaces
interface StateChanged {
(state: number, reason: number): void;
}
// Constructor properties interface
interface ConstructorProps extends Object.ConstructorProps {
connection: RemoteConnection;
controller: Device;
default: boolean;
default6: boolean;
devices: Device[];
dhcp4_config: DhcpConfig;
dhcp4Config: DhcpConfig;
dhcp6_config: DhcpConfig;
dhcp6Config: DhcpConfig;
id: string;
ip4_config: IPConfig;
ip4Config: IPConfig;
ip6_config: IPConfig;
ip6Config: IPConfig;
master: Device;
specific_object_path: string;
specificObjectPath: string;
state: ActiveConnectionState;
state_flags: number;
stateFlags: number;
type: string;
uuid: string;
vpn: boolean;
}
}
class ActiveConnection extends Object {
static $gtype: GObject.GType;
// Properties
/**
* The connection that this is an active instance of.
*/
get connection(): RemoteConnection;
/**
* The controller device if one exists. This replaces the deprecated
* "master" property.
*/
get controller(): Device;
/**
* Whether the active connection is the default IPv4 one.
*/
get default(): boolean;
/**
* Whether the active connection is the default IPv6 one.
*/
get default6(): boolean;
/**
* The devices of the active connection.
*/
get devices(): Device[];
/**
* The IPv4 #NMDhcpConfig of the connection.
*/
get dhcp4_config(): DhcpConfig;
/**
* The IPv4 #NMDhcpConfig of the connection.
*/
get dhcp4Config(): DhcpConfig;
/**
* The IPv6 #NMDhcpConfig of the connection.
*/
get dhcp6_config(): DhcpConfig;
/**
* The IPv6 #NMDhcpConfig of the connection.
*/
get dhcp6Config(): DhcpConfig;
/**
* The active connection's ID
*/
get id(): string;
/**
* The IPv4 #NMIPConfig of the connection.
*/
get ip4_config(): IPConfig;
/**
* The IPv4 #NMIPConfig of the connection.
*/
get ip4Config(): IPConfig;
/**
* The IPv6 #NMIPConfig of the connection.
*/
get ip6_config(): IPConfig;
/**
* The IPv6 #NMIPConfig of the connection.
*/
get ip6Config(): IPConfig;
/**
* The controller device if one exists. Replaced by the "controller" property.
*/
get master(): Device;
/**
* The path to the "specific object" of the active connection; see
* nm_active_connection_get_specific_object_path() for more details.
*/
get specific_object_path(): string;
/**
* The path to the "specific object" of the active connection; see
* nm_active_connection_get_specific_object_path() for more details.
*/
get specificObjectPath(): string;
/**
* The state of the active connection.
*/
get state(): ActiveConnectionState;
/**
* The state flags of the active connection.
*/
get state_flags(): number;
/**
* The state flags of the active connection.
*/
get stateFlags(): number;
/**
* The active connection's type
*/
get type(): string;
/**
* The active connection's UUID
*/
get uuid(): string;
/**
* Whether the active connection is a VPN connection.
*/
get vpn(): boolean;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Signals
connect(id: string, callback: (...args: any[]) => any): number;
connect_after(id: string, callback: (...args: any[]) => any): number;
emit(id: string, ...args: any[]): void;
connect(signal: 'state-changed', callback: (_source: this, state: number, reason: number) => void): number;
connect_after(
signal: 'state-changed',
callback: (_source: this, state: number, reason: number) => void,
): number;
emit(signal: 'state-changed', state: number, reason: number): void;
// Methods
/**
* Gets the #NMRemoteConnection associated with `connection`.
* @returns the #NMRemoteConnection which this #NMActiveConnection is an active instance of.
*/
get_connection(): RemoteConnection;
/**
* Gets the #NMConnection's type.
* @returns the type of the #NMConnection that backs the #NMActiveConnection. This is the internal string used by the connection, and must not be modified.
*/
get_connection_type(): string;
/**
* Gets the controller #NMDevice of the connection. This replaces the
* deprecated nm_active_connection_get_master() method.
* @returns the controller #NMDevice of the #NMActiveConnection.
*/
get_controller(): any | null;
/**
* Whether the active connection is the default IPv4 one (that is, is used for
* the default IPv4 route and DNS information).
* @returns %TRUE if the active connection is the default IPv4 connection
*/
get_default(): boolean;
/**
* Whether the active connection is the default IPv6 one (that is, is used for
* the default IPv6 route and DNS information).
* @returns %TRUE if the active connection is the default IPv6 connection
*/
get_default6(): boolean;
/**
* Gets the #NMDevices used for the active connections.
* @returns the #GPtrArray containing #NMDevices. This is the internal copy used by the connection, and must not be modified.
*/
get_devices(): Device[];
/**
* Gets the current IPv4 #NMDhcpConfig (if any) associated with the
* #NMActiveConnection.
* @returns the IPv4 #NMDhcpConfig, or %NULL if the connection does not use DHCP, or is not in the %NM_ACTIVE_CONNECTION_STATE_ACTIVATED state.
*/
get_dhcp4_config(): DhcpConfig;
/**
* Gets the current IPv6 #NMDhcpConfig (if any) associated with the
* #NMActiveConnection.
* @returns the IPv6 #NMDhcpConfig, or %NULL if the connection does not use DHCPv6, or is not in the %NM_ACTIVE_CONNECTION_STATE_ACTIVATED state.
*/
get_dhcp6_config(): DhcpConfig;
/**
* Gets the #NMConnection's ID.
* @returns the ID of the #NMConnection that backs the #NMActiveConnection. This is the internal string used by the connection, and must not be modified.
*/
get_id(): string;
/**
* Gets the current IPv4 #NMIPConfig associated with the #NMActiveConnection.
* @returns the IPv4 #NMIPConfig, or %NULL if the connection is not in the %NM_ACTIVE_CONNECTION_STATE_ACTIVATED state.
*/
get_ip4_config(): IPConfig;
/**
* Gets the current IPv6 #NMIPConfig associated with the #NMActiveConnection.
* @returns the IPv6 #NMIPConfig, or %NULL if the connection is not in the %NM_ACTIVE_CONNECTION_STATE_ACTIVATED state.
*/
get_ip6_config(): IPConfig;
/**
* Gets the controller #NMDevice of the connection.
* @returns the controller #NMDevice of the #NMActiveConnection.
*/
get_master(): any | null;
/**
* Gets the path of the "specific object" used at activation.
*
* Currently, there is no single method that will allow you to automatically turn
* this into an appropriate #NMObject; you need to know what kind of object it
* is based on other information. (Eg, if `connection` corresponds to a Wi-Fi
* connection, then the specific object will be an #NMAccessPoint, and you can
* resolve it with nm_device_wifi_get_access_point_by_path().)
* @returns the specific object's D-Bus path. This is the internal string used by the connection, and must not be modified.
*/
get_specific_object_path(): string;
/**
* Gets the active connection's state.
* @returns the state
*/
get_state(): ActiveConnectionState;
/**
* Gets the active connection's state flags.
* @returns the state flags
*/
get_state_flags(): ActivationStateFlags;
/**
* Gets the reason for active connection's state.
* @returns the reason
*/
get_state_reason(): ActiveConnectionStateReason;
/**
* Gets the #NMConnection's UUID.
* @returns the UUID of the #NMConnection that backs the #NMActiveConnection. This is the internal string used by the connection, and must not be modified.
*/
get_uuid(): string;
/**
* Whether the active connection is a VPN connection.
* @returns %TRUE if the active connection is a VPN connection
*/
get_vpn(): boolean;
}
namespace Checkpoint {
// Constructor properties interface
interface ConstructorProps extends Object.ConstructorProps {
created: number;
devices: Device[];
rollback_timeout: number;
rollbackTimeout: number;
}
}
class Checkpoint extends Object {
static $gtype: GObject.GType;
// Properties
/**
* The timestamp (in CLOCK_BOOTTIME milliseconds) of checkpoint creation.
*/
get created(): number;
/**
* The devices that are part of this checkpoint.
*/
get devices(): Device[];
/**
* Timeout in seconds for automatic rollback, or zero.
*/
get rollback_timeout(): number;
/**
* Timeout in seconds for automatic rollback, or zero.
*/
get rollbackTimeout(): number;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
/**
* Gets the timestamp (in CLOCK_BOOTTIME milliseconds) of checkpoint creation.
*
* Use nm_utils_get_timestamp_msec() to obtain current time value suitable for
* comparing to this value.
* @returns the timestamp of checkpoint creation.
*/
get_created(): number;
/**
* The devices that are part of this checkpoint.
* @returns the devices list.
*/
get_devices(): Device[];
/**
* Gets the timeout in seconds for automatic rollback.
* @returns the rollback timeout.
*/
get_rollback_timeout(): number;
}
namespace Client {
// Signal callback interfaces
interface ActiveConnectionAdded {
(active_connection: ActiveConnection): void;
}
interface ActiveConnectionRemoved {
(active_connection: ActiveConnection): void;
}
interface AnyDeviceAdded {
(device: Device): void;
}
interface AnyDeviceRemoved {
(device: Device): void;
}
interface ConnectionAdded {
(connection: RemoteConnection): void;
}
interface ConnectionRemoved {
(connection: RemoteConnection): void;
}
interface DeviceAdded {
(device: Device): void;
}
interface DeviceRemoved {
(device: Device): void;
}
interface PermissionChanged {
(permission: number, result: number): void;
}
// Constructor properties interface
interface ConstructorProps
extends GObject.Object.ConstructorProps,
Gio.AsyncInitable.ConstructorProps,
Gio.Initable.ConstructorProps {
activating_connection: ActiveConnection;
activatingConnection: ActiveConnection;
active_connections: ActiveConnection[];
activeConnections: ActiveConnection[];
all_devices: Device[];
allDevices: Device[];
can_modify: boolean;
canModify: boolean;
capabilities: number[];
checkpoints: Checkpoint[];
connections: RemoteConnection[];
connectivity: ConnectivityState;
connectivity_check_available: boolean;
connectivityCheckAvailable: boolean;
connectivity_check_enabled: boolean;
connectivityCheckEnabled: boolean;
connectivity_check_uri: string;
connectivityCheckUri: string;
dbus_connection: Gio.DBusConnection;
dbusConnection: Gio.DBusConnection;
dbus_name_owner: string;
dbusNameOwner: string;
devices: Device[];
dns_configuration: DnsEntry[];
dnsConfiguration: DnsEntry[];
dns_mode: string;
dnsMode: string;
dns_rc_manager: string;
dnsRcManager: string;
hostname: string;
instance_flags: number;
instanceFlags: number;
metered: number;
networking_enabled: boolean;
networkingEnabled: boolean;
nm_running: boolean;
nmRunning: boolean;
permissions_state: Ternary;
permissionsState: Ternary;
primary_connection: ActiveConnection;
primaryConnection: ActiveConnection;
radio_flags: number;
radioFlags: number;
startup: boolean;
state: State;
version: string;
version_info: number[];
versionInfo: number[];
wimax_enabled: boolean;
wimaxEnabled: boolean;
wimax_hardware_enabled: boolean;
wimaxHardwareEnabled: boolean;
wireless_enabled: boolean;
wirelessEnabled: boolean;
wireless_hardware_enabled: boolean;
wirelessHardwareEnabled: boolean;
wwan_enabled: boolean;
wwanEnabled: boolean;
wwan_hardware_enabled: boolean;
wwanHardwareEnabled: boolean;
}
}
/**
* NMClient contains a cache of the objects of NetworkManager's D-Bus API.
* It uses #GMainContext and #GDBusConnection for that and registers to
* D-Bus signals. That means, when iterating the associated #GMainContext,
* D-Bus signals gets processed and the #NMClient instance updates and
* emits #GObject signals.
*/
class Client extends GObject.Object implements Gio.AsyncInitable, Gio.Initable {
static $gtype: GObject.GType;
// Properties
/**
* The #NMActiveConnection of the activating connection that is
* likely to become the new #NMClient:primary-connection.
*/
get activating_connection(): ActiveConnection;
/**
* The #NMActiveConnection of the activating connection that is
* likely to become the new #NMClient:primary-connection.
*/
get activatingConnection(): ActiveConnection;
/**
* The active connections.
*/
get active_connections(): ActiveConnection[];
/**
* The active connections.
*/
get activeConnections(): ActiveConnection[];
/**
* List of both real devices and device placeholders.
*/
get all_devices(): Device[];
/**
* List of both real devices and device placeholders.
*/
get allDevices(): Device[];
/**
* If %TRUE, adding and modifying connections is supported.
*/
get can_modify(): boolean;
/**
* If %TRUE, adding and modifying connections is supported.
*/
get canModify(): boolean;
/**
* The list of capabilities numbers as guint32 or %NULL if
* there are no capabilities. The numeric value correspond
* to %NMCapability enum.
*/
get capabilities(): number[];
/**
* The list of active checkpoints.
*/
get checkpoints(): Checkpoint[];
/**
* The list of configured connections that are available to the user. (Note
* that this differs from the underlying D-Bus property, which may also
* contain the object paths of connections that the user does not have
* permission to read the details of.)
*/
get connections(): RemoteConnection[];
/**
* The network connectivity state.
*/
get connectivity(): ConnectivityState;
get connectivity_check_available(): boolean;
get connectivityCheckAvailable(): boolean;
get connectivity_check_enabled(): boolean;
set connectivity_check_enabled(val: boolean);
get connectivityCheckEnabled(): boolean;
set connectivityCheckEnabled(val: boolean);
/**
* The used URI for connectivity checking.
*/
get connectivity_check_uri(): string;
/**
* The used URI for connectivity checking.
*/
get connectivityCheckUri(): string;
/**
* The #GDBusConnection to use.
*
* If this is not set during object construction, the D-Bus connection will
* automatically be chosen during async/sync initalization via g_bus_get().
*/
get dbus_connection(): Gio.DBusConnection;
/**
* The #GDBusConnection to use.
*
* If this is not set during object construction, the D-Bus connection will
* automatically be chosen during async/sync initalization via g_bus_get().
*/
get dbusConnection(): Gio.DBusConnection;
/**
* The name owner of the NetworkManager D-Bus service.
*/
get dbus_name_owner(): string;
/**
* The name owner of the NetworkManager D-Bus service.
*/
get dbusNameOwner(): string;
/**
* List of real network devices. Does not include placeholder devices.
*/
get devices(): Device[];
/**
* The current DNS configuration, represented as an array
* of #NMDnsEntry objects.
*/
get dns_configuration(): DnsEntry[];
/**
* The current DNS configuration, represented as an array
* of #NMDnsEntry objects.
*/
get dnsConfiguration(): DnsEntry[];
/**
* The current DNS processing mode.
*/
get dns_mode(): string;
/**
* The current DNS processing mode.
*/
get dnsMode(): string;
/**
* The current resolv.conf management mode.
*/
get dns_rc_manager(): string;
/**
* The current resolv.conf management mode.
*/
get dnsRcManager(): string;
/**
* The machine hostname stored in persistent configuration. This can be
* modified by calling nm_client_save_hostname().
*/
get hostname(): string;
/**
* #NMClientInstanceFlags for the instance. These affect behavior of #NMClient.
* This is a construct property and you may only set most flags only during
* construction.
*
* The flag %NM_CLIENT_INSTANCE_FLAGS_NO_AUTO_FETCH_PERMISSIONS can be toggled any time,
* even after constructing the instance. Note that you may want to watch NMClient:permissions-state
* property to know whether permissions are ready. Note that permissions are only fetched
* when NMClient has a D-Bus name owner.
*
* The flags %NM_CLIENT_INSTANCE_FLAGS_INITIALIZED_GOOD and %NM_CLIENT_INSTANCE_FLAGS_INITIALIZED_BAD
* cannot be set, however they will be returned by the getter after initialization completes.
*/
get instance_flags(): number;
set instance_flags(val: number);
/**
* #NMClientInstanceFlags for the instance. These affect behavior of #NMClient.
* This is a construct property and you may only set most flags only during
* construction.
*
* The flag %NM_CLIENT_INSTANCE_FLAGS_NO_AUTO_FETCH_PERMISSIONS can be toggled any time,
* even after constructing the instance. Note that you may want to watch NMClient:permissions-state
* property to know whether permissions are ready. Note that permissions are only fetched
* when NMClient has a D-Bus name owner.
*
* The flags %NM_CLIENT_INSTANCE_FLAGS_INITIALIZED_GOOD and %NM_CLIENT_INSTANCE_FLAGS_INITIALIZED_BAD
* cannot be set, however they will be returned by the getter after initialization completes.
*/
get instanceFlags(): number;
set instanceFlags(val: number);
/**
* Whether the connectivity is metered.
*/
get metered(): number;
/**
* Whether networking is enabled.
*
* The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
*/
get networking_enabled(): boolean;
set networking_enabled(val: boolean);
/**
* Whether networking is enabled.
*
* The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
*/
get networkingEnabled(): boolean;
set networkingEnabled(val: boolean);
/**
* Whether the daemon is running.
*/
get nm_running(): boolean;
/**
* Whether the daemon is running.
*/
get nmRunning(): boolean;
/**
* The state of the cached permissions. The value %NM_TERNARY_DEFAULT
* means that no permissions are yet received (or not yet requested).
* %NM_TERNARY_TRUE means that permissions are received, cached and up
* to date. %NM_TERNARY_FALSE means that permissions were received and are
* cached, but in the meantime a "CheckPermissions" signal was received
* that invalidated the cached permissions.
* Note that NMClient will always emit a notify::permissions-state signal
* when a "CheckPermissions" signal got received or after new permissions
* got received (that is regardless whether the value of the permission state
* actually changed). With this you can watch the permissions-state property
* to know whether the permissions are ready. Note that while NMClient has
* no D-Bus name owner, no permissions are fetched (and this property won't
* change).
*/
get permissions_state(): Ternary;
/**
* The state of the cached permissions. The value %NM_TERNARY_DEFAULT
* means that no permissions are yet received (or not yet requested).
* %NM_TERNARY_TRUE means that permissions are received, cached and up
* to date. %NM_TERNARY_FALSE means that permissions were received and are
* cached, but in the meantime a "CheckPermissions" signal was received
* that invalidated the cached permissions.
* Note that NMClient will always emit a notify::permissions-state signal
* when a "CheckPermissions" signal got received or after new permissions
* got received (that is regardless whether the value of the permission state
* actually changed). With this you can watch the permissions-state property
* to know whether the permissions are ready. Note that while NMClient has
* no D-Bus name owner, no permissions are fetched (and this property won't
* change).
*/
get permissionsState(): Ternary;
/**
* The #NMActiveConnection of the device with the default route;
* see nm_client_get_primary_connection() for more details.
*/
get primary_connection(): ActiveConnection;
/**
* The #NMActiveConnection of the device with the default route;
* see nm_client_get_primary_connection() for more details.
*/
get primaryConnection(): ActiveConnection;
/**
* Flags for radio interfaces. See #NMRadioFlags.
*/
get radio_flags(): number;
/**
* Flags for radio interfaces. See #NMRadioFlags.
*/
get radioFlags(): number;
/**
* Whether the daemon is still starting up.
*/
get startup(): boolean;
/**
* The current daemon state.
*/
get state(): State;
/**
* The NetworkManager version.
*/
get version(): string;
/**
* Expose version info and capabilities of NetworkManager. If non-empty,
* the first element is NM_VERSION, which encodes the version of the
* daemon as "(major << 16 | minor << 8 | micro)". The following elements
* is a bitfields of %NMVersionInfoCapability. If a bit is set, then
* the running NetworkManager has the respective capability.
*/
get version_info(): number[];
/**
* Expose version info and capabilities of NetworkManager. If non-empty,
* the first element is NM_VERSION, which encodes the version of the
* daemon as "(major << 16 | minor << 8 | micro)". The following elements
* is a bitfields of %NMVersionInfoCapability. If a bit is set, then
* the running NetworkManager has the respective capability.
*/
get versionInfo(): number[];
/**
* Whether WiMAX functionality is enabled.
*/
get wimax_enabled(): boolean;
set wimax_enabled(val: boolean);
/**
* Whether WiMAX functionality is enabled.
*/
get wimaxEnabled(): boolean;
set wimaxEnabled(val: boolean);
/**
* Whether the WiMAX hardware is enabled.
*/
get wimax_hardware_enabled(): boolean;
/**
* Whether the WiMAX hardware is enabled.
*/
get wimaxHardwareEnabled(): boolean;
/**
* Whether wireless is enabled.
*
* The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
*/
get wireless_enabled(): boolean;
set wireless_enabled(val: boolean);
/**
* Whether wireless is enabled.
*
* The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
*/
get wirelessEnabled(): boolean;
set wirelessEnabled(val: boolean);
/**
* Whether the wireless hardware is enabled.
*/
get wireless_hardware_enabled(): boolean;
/**
* Whether the wireless hardware is enabled.
*/
get wirelessHardwareEnabled(): boolean;
/**
* Whether WWAN functionality is enabled.
*
* The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
*/
get wwan_enabled(): boolean;
set wwan_enabled(val: boolean);
/**
* Whether WWAN functionality is enabled.
*
* The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
*/
get wwanEnabled(): boolean;
set wwanEnabled(val: boolean);
/**
* Whether the WWAN hardware is enabled.
*/
get wwan_hardware_enabled(): boolean;
/**
* Whether the WWAN hardware is enabled.
*/
get wwanHardwareEnabled(): boolean;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
static ['new'](cancellable?: Gio.Cancellable | null): Client;
static new_finish(result: Gio.AsyncResult): Client;
// Conflicted with Gio.AsyncInitable.new_finish
static new_finish(...args: never[]): any;
// Signals
connect(id: string, callback: (...args: any[]) => any): number;
connect_after(id: string, callback: (...args: any[]) => any): number;
emit(id: string, ...args: any[]): void;
connect(
signal: 'active-connection-added',
callback: (_source: this, active_connection: ActiveConnection) => void,
): number;
connect_after(
signal: 'active-connection-added',
callback: (_source: this, active_connection: ActiveConnection) => void,
): number;
emit(signal: 'active-connection-added', active_connection: ActiveConnection): void;
connect(
signal: 'active-connection-removed',
callback: (_source: this, active_connection: ActiveConnection) => void,
): number;
connect_after(
signal: 'active-connection-removed',
callback: (_source: this, active_connection: ActiveConnection) => void,
): number;
emit(signal: 'active-connection-removed', active_connection: ActiveConnection): void;
connect(signal: 'any-device-added', callback: (_source: this, device: Device) => void): number;
connect_after(signal: 'any-device-added', callback: (_source: this, device: Device) => void): number;
emit(signal: 'any-device-added', device: Device): void;
connect(signal: 'any-device-removed', callback: (_source: this, device: Device) => void): number;
connect_after(signal: 'any-device-removed', callback: (_source: this, device: Device) => void): number;
emit(signal: 'any-device-removed', device: Device): void;
connect(
signal: 'connection-added',
callback: (_source: this, connection: RemoteConnection) => void,
): number;
connect_after(
signal: 'connection-added',
callback: (_source: this, connection: RemoteConnection) => void,
): number;
emit(signal: 'connection-added', connection: RemoteConnection): void;
connect(
signal: 'connection-removed',
callback: (_source: this, connection: RemoteConnection) => void,
): number;
connect_after(
signal: 'connection-removed',
callback: (_source: this, connection: RemoteConnection) => void,
): number;
emit(signal: 'connection-removed', connection: RemoteConnection): void;
connect(signal: 'device-added', callback: (_source: this, device: Device) => void): number;
connect_after(signal: 'device-added', callback: (_source: this, device: Device) => void): number;
emit(signal: 'device-added', device: Device): void;
connect(signal: 'device-removed', callback: (_source: this, device: Device) => void): number;
connect_after(signal: 'device-removed', callback: (_source: this, device: Device) => void): number;
emit(signal: 'device-removed', device: Device): void;
connect(
signal: 'permission-changed',
callback: (_source: this, permission: number, result: number) => void,
): number;
connect_after(
signal: 'permission-changed',
callback: (_source: this, permission: number, result: number) => void,
): number;
emit(signal: 'permission-changed', permission: number, result: number): void;
// Static methods
/**
* Creates a new #NMClient asynchronously.
* `callback` will be called when it is done. Use
* nm_client_new_finish() to get the result.
*
* This does nothing beside calling g_async_initable_new_async(). You are free to
* call g_async_initable_new_async() or g_object_new()/g_async_initable_init_async()
* directly for more control, to set GObject properties or get access to the NMClient
* instance while it is still initializing.
*
* Creating an #NMClient instance can only fail for two reasons. First, if you didn't
* provide a %NM_CLIENT_DBUS_CONNECTION and the call to g_bus_get()
* fails. You can avoid that by using g_async_initable_new_async() directly and
* set a D-Bus connection.
* Second, if you cancelled the creation. If you do that, then note
* that after the failure there might still be idle actions pending
* which keep nm_client_get_main_context() alive. That means,
* in that case you must continue iterating the context to avoid
* leaks. See nm_client_get_context_busy_watcher().
*
* Creating an #NMClient instance when NetworkManager is not running
* does not cause a failure.
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to call when the client is created
*/
static new_async(
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): void;
static wait_shutdown_finish(result: Gio.AsyncResult): boolean;
// Methods
/**
* Asynchronously starts a connection to a particular network using the
* configuration settings from `connection` and the network device `device`.
* Certain connection types also take a "specific object" which is the object
* path of a connection- specific object, like an #NMAccessPoint for Wi-Fi
* connections, or an #NMWimaxNsp for WiMAX connections, to which you wish to
* connect. If the specific object is not given, NetworkManager can, in some
* cases, automatically determine which network to connect to given the settings
* in `connection`.
*
* If `connection` is not given for a device-based activation, NetworkManager
* picks the best available connection for the device and activates it.
*
* Note that the callback is invoked when NetworkManager has started activating
* the new connection, not when it finishes. You can use the returned
* #NMActiveConnection object (in particular, #NMActiveConnection:state) to
* track the activation to its completion.
* @param connection an #NMConnection
* @param device the #NMDevice
* @param specific_object the object path of a connection-type-specific object this activation should use. This parameter is currently ignored for wired and mobile broadband connections, and the value of %NULL should be used (ie, no specific object). For Wi-Fi or WiMAX connections, pass the object path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can get using nm_object_get_path(), and which will be used to complete the details of the newly added connection.
* @param cancellable a #GCancellable, or %NULL
*/
activate_connection_async(
connection?: Connection | null,
device?: Device | null,
specific_object?: string | null,
cancellable?: Gio.Cancellable | null,
): Promise;
/**
* Asynchronously starts a connection to a particular network using the
* configuration settings from `connection` and the network device `device`.
* Certain connection types also take a "specific object" which is the object
* path of a connection- specific object, like an #NMAccessPoint for Wi-Fi
* connections, or an #NMWimaxNsp for WiMAX connections, to which you wish to
* connect. If the specific object is not given, NetworkManager can, in some
* cases, automatically determine which network to connect to given the settings
* in `connection`.
*
* If `connection` is not given for a device-based activation, NetworkManager
* picks the best available connection for the device and activates it.
*
* Note that the callback is invoked when NetworkManager has started activating
* the new connection, not when it finishes. You can use the returned
* #NMActiveConnection object (in particular, #NMActiveConnection:state) to
* track the activation to its completion.
* @param connection an #NMConnection
* @param device the #NMDevice
* @param specific_object the object path of a connection-type-specific object this activation should use. This parameter is currently ignored for wired and mobile broadband connections, and the value of %NULL should be used (ie, no specific object). For Wi-Fi or WiMAX connections, pass the object path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can get using nm_object_get_path(), and which will be used to complete the details of the newly added connection.
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the activation has started
*/
activate_connection_async(
connection: Connection | null,
device: Device | null,
specific_object: string | null,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback | null,
): void;
/**
* Asynchronously starts a connection to a particular network using the
* configuration settings from `connection` and the network device `device`.
* Certain connection types also take a "specific object" which is the object
* path of a connection- specific object, like an #NMAccessPoint for Wi-Fi
* connections, or an #NMWimaxNsp for WiMAX connections, to which you wish to
* connect. If the specific object is not given, NetworkManager can, in some
* cases, automatically determine which network to connect to given the settings
* in `connection`.
*
* If `connection` is not given for a device-based activation, NetworkManager
* picks the best available connection for the device and activates it.
*
* Note that the callback is invoked when NetworkManager has started activating
* the new connection, not when it finishes. You can use the returned
* #NMActiveConnection object (in particular, #NMActiveConnection:state) to
* track the activation to its completion.
* @param connection an #NMConnection
* @param device the #NMDevice
* @param specific_object the object path of a connection-type-specific object this activation should use. This parameter is currently ignored for wired and mobile broadband connections, and the value of %NULL should be used (ie, no specific object). For Wi-Fi or WiMAX connections, pass the object path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can get using nm_object_get_path(), and which will be used to complete the details of the newly added connection.
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the activation has started
*/
activate_connection_async(
connection?: Connection | null,
device?: Device | null,
specific_object?: string | null,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise | void;
/**
* Gets the result of a call to nm_client_activate_connection_async().
* @param result the result passed to the #GAsyncReadyCallback
* @returns the new #NMActiveConnection on success, %NULL on failure, in which case @error will be set.
*/
activate_connection_finish(result: Gio.AsyncResult): ActiveConnection;
/**
* Adds a new connection using the given details (if any) as a template,
* automatically filling in missing settings with the capabilities of the given
* device and specific object. The new connection is then asynchronously
* activated as with nm_client_activate_connection_async(). Cannot be used for
* VPN connections at this time.
*
* Note that the callback is invoked when NetworkManager has started activating
* the new connection, not when it finishes. You can used the returned
* #NMActiveConnection object (in particular, #NMActiveConnection:state) to
* track the activation to its completion.
*
* This is identical to nm_client_add_and_activate_connection_async() but takes
* a further `options` parameter. Currently, the following options are supported
* by the daemon:
* * "persist": A string describing how the connection should be stored.
* The default is "disk", but it can be modified to "memory" (until
* the daemon quits) or "volatile" (will be deleted on disconnect).
* * "bind-activation": Bind the connection lifetime to something. The default is "none",
* meaning an explicit disconnect is needed. The value "dbus-client"
* means the connection will automatically be deactivated when the calling
* D-Bus client disappears from the system bus.
* @param partial an #NMConnection to add; the connection may be partially filled (or even %NULL) and will be completed by NetworkManager using the given @device and @specific_object before being added
* @param device the #NMDevice
* @param specific_object the object path of a connection-type-specific object this activation should use. This parameter is currently ignored for wired and mobile broadband connections, and the value of %NULL should be used (i.e., no specific object). For Wi-Fi or WiMAX connections, pass the object path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can get using nm_object_get_path(), and which will be used to complete the details of the newly added connection.
* @param options a #GVariant containing a dictionary with options, or %NULL
* @param cancellable a #GCancellable, or %NULL
*/
add_and_activate_connection2(
partial: Connection | null,
device: Device | null,
specific_object: string | null,
options: GLib.Variant,
cancellable?: Gio.Cancellable | null,
): Promise<[ActiveConnection, GLib.Variant | null]>;
/**
* Adds a new connection using the given details (if any) as a template,
* automatically filling in missing settings with the capabilities of the given
* device and specific object. The new connection is then asynchronously
* activated as with nm_client_activate_connection_async(). Cannot be used for
* VPN connections at this time.
*
* Note that the callback is invoked when NetworkManager has started activating
* the new connection, not when it finishes. You can used the returned
* #NMActiveConnection object (in particular, #NMActiveConnection:state) to
* track the activation to its completion.
*
* This is identical to nm_client_add_and_activate_connection_async() but takes
* a further `options` parameter. Currently, the following options are supported
* by the daemon:
* * "persist": A string describing how the connection should be stored.
* The default is "disk", but it can be modified to "memory" (until
* the daemon quits) or "volatile" (will be deleted on disconnect).
* * "bind-activation": Bind the connection lifetime to something. The default is "none",
* meaning an explicit disconnect is needed. The value "dbus-client"
* means the connection will automatically be deactivated when the calling
* D-Bus client disappears from the system bus.
* @param partial an #NMConnection to add; the connection may be partially filled (or even %NULL) and will be completed by NetworkManager using the given @device and @specific_object before being added
* @param device the #NMDevice
* @param specific_object the object path of a connection-type-specific object this activation should use. This parameter is currently ignored for wired and mobile broadband connections, and the value of %NULL should be used (i.e., no specific object). For Wi-Fi or WiMAX connections, pass the object path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can get using nm_object_get_path(), and which will be used to complete the details of the newly added connection.
* @param options a #GVariant containing a dictionary with options, or %NULL
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the activation has started
*/
add_and_activate_connection2(
partial: Connection | null,
device: Device | null,
specific_object: string | null,
options: GLib.Variant,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback | null,
): void;
/**
* Adds a new connection using the given details (if any) as a template,
* automatically filling in missing settings with the capabilities of the given
* device and specific object. The new connection is then asynchronously
* activated as with nm_client_activate_connection_async(). Cannot be used for
* VPN connections at this time.
*
* Note that the callback is invoked when NetworkManager has started activating
* the new connection, not when it finishes. You can used the returned
* #NMActiveConnection object (in particular, #NMActiveConnection:state) to
* track the activation to its completion.
*
* This is identical to nm_client_add_and_activate_connection_async() but takes
* a further `options` parameter. Currently, the following options are supported
* by the daemon:
* * "persist": A string describing how the connection should be stored.
* The default is "disk", but it can be modified to "memory" (until
* the daemon quits) or "volatile" (will be deleted on disconnect).
* * "bind-activation": Bind the connection lifetime to something. The default is "none",
* meaning an explicit disconnect is needed. The value "dbus-client"
* means the connection will automatically be deactivated when the calling
* D-Bus client disappears from the system bus.
* @param partial an #NMConnection to add; the connection may be partially filled (or even %NULL) and will be completed by NetworkManager using the given @device and @specific_object before being added
* @param device the #NMDevice
* @param specific_object the object path of a connection-type-specific object this activation should use. This parameter is currently ignored for wired and mobile broadband connections, and the value of %NULL should be used (i.e., no specific object). For Wi-Fi or WiMAX connections, pass the object path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can get using nm_object_get_path(), and which will be used to complete the details of the newly added connection.
* @param options a #GVariant containing a dictionary with options, or %NULL
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the activation has started
*/
add_and_activate_connection2(
partial: Connection | null,
device: Device | null,
specific_object: string | null,
options: GLib.Variant,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise<[ActiveConnection, GLib.Variant | null]> | void;
/**
* Gets the result of a call to nm_client_add_and_activate_connection2().
*
* You can call nm_active_connection_get_connection() on the returned
* #NMActiveConnection to find the path of the created #NMConnection.
* @param result the result passed to the #GAsyncReadyCallback
* @returns the new #NMActiveConnection on success, %NULL on failure, in which case @error will be set.
*/
add_and_activate_connection2_finish(result: Gio.AsyncResult): [ActiveConnection, GLib.Variant | null];
/**
* Adds a new connection using the given details (if any) as a template,
* automatically filling in missing settings with the capabilities of the given
* device and specific object. The new connection is then asynchronously
* activated as with nm_client_activate_connection_async(). Cannot be used for
* VPN connections at this time.
*
* Note that the callback is invoked when NetworkManager has started activating
* the new connection, not when it finishes. You can used the returned
* #NMActiveConnection object (in particular, #NMActiveConnection:state) to
* track the activation to its completion.
* @param partial an #NMConnection to add; the connection may be partially filled (or even %NULL) and will be completed by NetworkManager using the given @device and @specific_object before being added
* @param device the #NMDevice
* @param specific_object the object path of a connection-type-specific object this activation should use. This parameter is currently ignored for wired and mobile broadband connections, and the value of %NULL should be used (ie, no specific object). For Wi-Fi or WiMAX connections, pass the object path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can get using nm_object_get_path(), and which will be used to complete the details of the newly added connection. If the variant is floating, it will be consumed.
* @param cancellable a #GCancellable, or %NULL
*/
add_and_activate_connection_async(
partial?: Connection | null,
device?: Device | null,
specific_object?: string | null,
cancellable?: Gio.Cancellable | null,
): Promise;
/**
* Adds a new connection using the given details (if any) as a template,
* automatically filling in missing settings with the capabilities of the given
* device and specific object. The new connection is then asynchronously
* activated as with nm_client_activate_connection_async(). Cannot be used for
* VPN connections at this time.
*
* Note that the callback is invoked when NetworkManager has started activating
* the new connection, not when it finishes. You can used the returned
* #NMActiveConnection object (in particular, #NMActiveConnection:state) to
* track the activation to its completion.
* @param partial an #NMConnection to add; the connection may be partially filled (or even %NULL) and will be completed by NetworkManager using the given @device and @specific_object before being added
* @param device the #NMDevice
* @param specific_object the object path of a connection-type-specific object this activation should use. This parameter is currently ignored for wired and mobile broadband connections, and the value of %NULL should be used (ie, no specific object). For Wi-Fi or WiMAX connections, pass the object path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can get using nm_object_get_path(), and which will be used to complete the details of the newly added connection. If the variant is floating, it will be consumed.
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the activation has started
*/
add_and_activate_connection_async(
partial: Connection | null,
device: Device | null,
specific_object: string | null,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback | null,
): void;
/**
* Adds a new connection using the given details (if any) as a template,
* automatically filling in missing settings with the capabilities of the given
* device and specific object. The new connection is then asynchronously
* activated as with nm_client_activate_connection_async(). Cannot be used for
* VPN connections at this time.
*
* Note that the callback is invoked when NetworkManager has started activating
* the new connection, not when it finishes. You can used the returned
* #NMActiveConnection object (in particular, #NMActiveConnection:state) to
* track the activation to its completion.
* @param partial an #NMConnection to add; the connection may be partially filled (or even %NULL) and will be completed by NetworkManager using the given @device and @specific_object before being added
* @param device the #NMDevice
* @param specific_object the object path of a connection-type-specific object this activation should use. This parameter is currently ignored for wired and mobile broadband connections, and the value of %NULL should be used (ie, no specific object). For Wi-Fi or WiMAX connections, pass the object path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can get using nm_object_get_path(), and which will be used to complete the details of the newly added connection. If the variant is floating, it will be consumed.
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the activation has started
*/
add_and_activate_connection_async(
partial?: Connection | null,
device?: Device | null,
specific_object?: string | null,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise | void;
/**
* Gets the result of a call to nm_client_add_and_activate_connection_async().
*
* You can call nm_active_connection_get_connection() on the returned
* #NMActiveConnection to find the path of the created #NMConnection.
* @param result the result passed to the #GAsyncReadyCallback
* @returns the new #NMActiveConnection on success, %NULL on failure, in which case @error will be set.
*/
add_and_activate_connection_finish(result: Gio.AsyncResult): ActiveConnection;
/**
* Call AddConnection2() D-Bus API asynchronously.
* @param settings the "a{sa{sv}}" #GVariant with the content of the setting.
* @param flags the %NMSettingsAddConnection2Flags argument.
* @param args the "a{sv}" #GVariant with extra argument or %NULL for no extra arguments.
* @param ignore_out_result this function wraps AddConnection2(), which has an additional result "a{sv}" output parameter. By setting this to %TRUE, you signal that you are not interested in that output parameter. This allows the function to fall back to AddConnection() and AddConnectionUnsaved(), which is interesting if you run against an older server version that does not yet provide AddConnection2(). By setting this to %FALSE, the function under the hood always calls AddConnection2().
* @param cancellable a #GCancellable, or %NULL
*/
add_connection2(
settings: GLib.Variant,
flags: SettingsAddConnection2Flags | null,
args: GLib.Variant | null,
ignore_out_result: boolean,
cancellable?: Gio.Cancellable | null,
): Promise<[RemoteConnection, GLib.Variant | null]>;
/**
* Call AddConnection2() D-Bus API asynchronously.
* @param settings the "a{sa{sv}}" #GVariant with the content of the setting.
* @param flags the %NMSettingsAddConnection2Flags argument.
* @param args the "a{sv}" #GVariant with extra argument or %NULL for no extra arguments.
* @param ignore_out_result this function wraps AddConnection2(), which has an additional result "a{sv}" output parameter. By setting this to %TRUE, you signal that you are not interested in that output parameter. This allows the function to fall back to AddConnection() and AddConnectionUnsaved(), which is interesting if you run against an older server version that does not yet provide AddConnection2(). By setting this to %FALSE, the function under the hood always calls AddConnection2().
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the add operation completes
*/
add_connection2(
settings: GLib.Variant,
flags: SettingsAddConnection2Flags | null,
args: GLib.Variant | null,
ignore_out_result: boolean,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback | null,
): void;
/**
* Call AddConnection2() D-Bus API asynchronously.
* @param settings the "a{sa{sv}}" #GVariant with the content of the setting.
* @param flags the %NMSettingsAddConnection2Flags argument.
* @param args the "a{sv}" #GVariant with extra argument or %NULL for no extra arguments.
* @param ignore_out_result this function wraps AddConnection2(), which has an additional result "a{sv}" output parameter. By setting this to %TRUE, you signal that you are not interested in that output parameter. This allows the function to fall back to AddConnection() and AddConnectionUnsaved(), which is interesting if you run against an older server version that does not yet provide AddConnection2(). By setting this to %FALSE, the function under the hood always calls AddConnection2().
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the add operation completes
*/
add_connection2(
settings: GLib.Variant,
flags: SettingsAddConnection2Flags | null,
args: GLib.Variant | null,
ignore_out_result: boolean,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise<[RemoteConnection, GLib.Variant | null]> | void;
add_connection2_finish(result: Gio.AsyncResult): [RemoteConnection, GLib.Variant | null];
/**
* Requests that the remote settings service add the given settings to a new
* connection. If `save_to_disk` is %TRUE, the connection is immediately written
* to disk; otherwise it is initially only stored in memory, but may be saved
* later by calling the connection's nm_remote_connection_commit_changes()
* method.
*
* `connection` is untouched by this function and only serves as a template of
* the settings to add. The #NMRemoteConnection object that represents what
* NetworkManager actually added is returned to `callback` when the addition
* operation is complete.
*
* Note that the #NMRemoteConnection returned in `callback` may not contain
* identical settings to `connection` as NetworkManager may perform automatic
* completion and/or normalization of connection properties.
* @param connection the connection to add. Note that this object's settings will be added, not the object itself
* @param save_to_disk whether to immediately save the connection to disk
* @param cancellable a #GCancellable, or %NULL
*/
add_connection_async(
connection: Connection,
save_to_disk: boolean,
cancellable?: Gio.Cancellable | null,
): Promise;
/**
* Requests that the remote settings service add the given settings to a new
* connection. If `save_to_disk` is %TRUE, the connection is immediately written
* to disk; otherwise it is initially only stored in memory, but may be saved
* later by calling the connection's nm_remote_connection_commit_changes()
* method.
*
* `connection` is untouched by this function and only serves as a template of
* the settings to add. The #NMRemoteConnection object that represents what
* NetworkManager actually added is returned to `callback` when the addition
* operation is complete.
*
* Note that the #NMRemoteConnection returned in `callback` may not contain
* identical settings to `connection` as NetworkManager may perform automatic
* completion and/or normalization of connection properties.
* @param connection the connection to add. Note that this object's settings will be added, not the object itself
* @param save_to_disk whether to immediately save the connection to disk
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the add operation completes
*/
add_connection_async(
connection: Connection,
save_to_disk: boolean,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback | null,
): void;
/**
* Requests that the remote settings service add the given settings to a new
* connection. If `save_to_disk` is %TRUE, the connection is immediately written
* to disk; otherwise it is initially only stored in memory, but may be saved
* later by calling the connection's nm_remote_connection_commit_changes()
* method.
*
* `connection` is untouched by this function and only serves as a template of
* the settings to add. The #NMRemoteConnection object that represents what
* NetworkManager actually added is returned to `callback` when the addition
* operation is complete.
*
* Note that the #NMRemoteConnection returned in `callback` may not contain
* identical settings to `connection` as NetworkManager may perform automatic
* completion and/or normalization of connection properties.
* @param connection the connection to add. Note that this object's settings will be added, not the object itself
* @param save_to_disk whether to immediately save the connection to disk
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the add operation completes
*/
add_connection_async(
connection: Connection,
save_to_disk: boolean,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise | void;
/**
* Gets the result of a call to nm_client_add_connection_async().
* @param result the result passed to the #GAsyncReadyCallback
* @returns the new #NMRemoteConnection on success, %NULL on failure, in which case @error will be set.
*/
add_connection_finish(result: Gio.AsyncResult): RemoteConnection;
/**
* Updates the network connectivity state and returns the (new)
* current state. Contrast nm_client_get_connectivity(), which returns
* the most recent known state without re-checking.
*
* This is a blocking call; use nm_client_check_connectivity_async()
* if you do not want to block.
* @param cancellable a #GCancellable
* @returns the (new) current connectivity state
*/
check_connectivity(cancellable?: Gio.Cancellable | null): ConnectivityState;
/**
* Asynchronously updates the network connectivity state and invokes
* `callback` when complete. Contrast nm_client_get_connectivity(),
* which (immediately) returns the most recent known state without
* re-checking, and nm_client_check_connectivity(), which blocks.
* @param cancellable a #GCancellable
*/
check_connectivity_async(cancellable?: Gio.Cancellable | null): Promise;
/**
* Asynchronously updates the network connectivity state and invokes
* `callback` when complete. Contrast nm_client_get_connectivity(),
* which (immediately) returns the most recent known state without
* re-checking, and nm_client_check_connectivity(), which blocks.
* @param cancellable a #GCancellable
* @param callback callback to call with the result
*/
check_connectivity_async(
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback | null,
): void;
/**
* Asynchronously updates the network connectivity state and invokes
* `callback` when complete. Contrast nm_client_get_connectivity(),
* which (immediately) returns the most recent known state without
* re-checking, and nm_client_check_connectivity(), which blocks.
* @param cancellable a #GCancellable
* @param callback callback to call with the result
*/
check_connectivity_async(
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise | void;
/**
* Retrieves the result of an nm_client_check_connectivity_async()
* call.
* @param result the #GAsyncResult
* @returns the (new) current connectivity state
*/
check_connectivity_finish(result: Gio.AsyncResult): ConnectivityState;
/**
* Resets the timeout for the checkpoint with path `checkpoint_path`
* to `timeout_add`.
* @param checkpoint_path a D-Bus path to a checkpoint
* @param add_timeout the timeout in seconds counting from now. Set to zero, to disable the timeout.
* @param cancellable a #GCancellable, or %NULL
*/
checkpoint_adjust_rollback_timeout(
checkpoint_path: string,
add_timeout: number,
cancellable?: Gio.Cancellable | null,
): Promise;
/**
* Resets the timeout for the checkpoint with path `checkpoint_path`
* to `timeout_add`.
* @param checkpoint_path a D-Bus path to a checkpoint
* @param add_timeout the timeout in seconds counting from now. Set to zero, to disable the timeout.
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the add operation completes
*/
checkpoint_adjust_rollback_timeout(
checkpoint_path: string,
add_timeout: number,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback | null,
): void;
/**
* Resets the timeout for the checkpoint with path `checkpoint_path`
* to `timeout_add`.
* @param checkpoint_path a D-Bus path to a checkpoint
* @param add_timeout the timeout in seconds counting from now. Set to zero, to disable the timeout.
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the add operation completes
*/
checkpoint_adjust_rollback_timeout(
checkpoint_path: string,
add_timeout: number,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise | void;
/**
* Gets the result of a call to nm_client_checkpoint_adjust_rollback_timeout().
* @param result the result passed to the #GAsyncReadyCallback
* @returns %TRUE on success or %FALSE on failure.
*/
checkpoint_adjust_rollback_timeout_finish(result: Gio.AsyncResult): boolean;
/**
* Creates a checkpoint of the current networking configuration
* for given interfaces. An empty `devices` argument means all
* devices. If `rollback_timeout` is not zero, a rollback is
* automatically performed after the given timeout.
* @param devices a list of devices for which a checkpoint should be created.
* @param rollback_timeout the rollback timeout in seconds
* @param flags creation flags
* @param cancellable a #GCancellable, or %NULL
*/
checkpoint_create(
devices: Device[],
rollback_timeout: number,
flags: CheckpointCreateFlags | null,
cancellable?: Gio.Cancellable | null,
): Promise;
/**
* Creates a checkpoint of the current networking configuration
* for given interfaces. An empty `devices` argument means all
* devices. If `rollback_timeout` is not zero, a rollback is
* automatically performed after the given timeout.
* @param devices a list of devices for which a checkpoint should be created.
* @param rollback_timeout the rollback timeout in seconds
* @param flags creation flags
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the add operation completes
*/
checkpoint_create(
devices: Device[],
rollback_timeout: number,
flags: CheckpointCreateFlags | null,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback | null,
): void;
/**
* Creates a checkpoint of the current networking configuration
* for given interfaces. An empty `devices` argument means all
* devices. If `rollback_timeout` is not zero, a rollback is
* automatically performed after the given timeout.
* @param devices a list of devices for which a checkpoint should be created.
* @param rollback_timeout the rollback timeout in seconds
* @param flags creation flags
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the add operation completes
*/
checkpoint_create(
devices: Device[],
rollback_timeout: number,
flags: CheckpointCreateFlags | null,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise | void;
/**
* Gets the result of a call to nm_client_checkpoint_create().
* @param result the result passed to the #GAsyncReadyCallback
* @returns the new #NMCheckpoint on success, %NULL on failure, in which case @error will be set.
*/
checkpoint_create_finish(result: Gio.AsyncResult): Checkpoint;
/**
* Destroys an existing checkpoint without performing a rollback.
* @param checkpoint_path the D-Bus path for the checkpoint
* @param cancellable a #GCancellable, or %NULL
*/
checkpoint_destroy(checkpoint_path: string, cancellable?: Gio.Cancellable | null): Promise;
/**
* Destroys an existing checkpoint without performing a rollback.
* @param checkpoint_path the D-Bus path for the checkpoint
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the add operation completes
*/
checkpoint_destroy(
checkpoint_path: string,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback | null,
): void;
/**
* Destroys an existing checkpoint without performing a rollback.
* @param checkpoint_path the D-Bus path for the checkpoint
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the add operation completes
*/
checkpoint_destroy(
checkpoint_path: string,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise | void;
/**
* Gets the result of a call to nm_client_checkpoint_destroy().
* @param result the result passed to the #GAsyncReadyCallback
* @returns %TRUE on success or %FALSE on failure, in which case @error will be set.
*/
checkpoint_destroy_finish(result: Gio.AsyncResult): boolean;
/**
* Performs the rollback of a checkpoint before the timeout is reached.
* @param checkpoint_path the D-Bus path to the checkpoint
* @param cancellable a #GCancellable, or %NULL
*/
checkpoint_rollback(
checkpoint_path: string,
cancellable?: Gio.Cancellable | null,
): Promise>;
/**
* Performs the rollback of a checkpoint before the timeout is reached.
* @param checkpoint_path the D-Bus path to the checkpoint
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the add operation completes
*/
checkpoint_rollback(
checkpoint_path: string,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback | null,
): void;
/**
* Performs the rollback of a checkpoint before the timeout is reached.
* @param checkpoint_path the D-Bus path to the checkpoint
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the add operation completes
*/
checkpoint_rollback(
checkpoint_path: string,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise> | void;
/**
* Gets the result of a call to nm_client_checkpoint_rollback().
* @param result the result passed to the #GAsyncReadyCallback
* @returns an hash table of devices and results. Devices are represented by their original D-Bus path; each result is a #NMRollbackResult.
*/
checkpoint_rollback_finish(result: Gio.AsyncResult): GLib.HashTable;
/**
* Determine whether connectivity checking is available. This
* requires that the URI of a connectivity service has been set in the
* configuration file.
* @returns %TRUE if connectivity checking is available.
*/
connectivity_check_get_available(): boolean;
/**
* Determine whether connectivity checking is enabled.
* @returns %TRUE if connectivity checking is enabled.
*/
connectivity_check_get_enabled(): boolean;
/**
* Get the URI that will be queried to determine if there is internet
* connectivity.
* @returns the connectivity URI in use
*/
connectivity_check_get_uri(): string;
/**
* Enable or disable connectivity checking. Note that if a
* connectivity checking URI has not been configured, this will not
* have any effect.
* @param enabled %TRUE to enable connectivity checking
*/
connectivity_check_set_enabled(enabled: boolean): void;
/**
* Call g_dbus_connection_call() on the current name owner with the specified
* arguments. Most importantly, this invokes g_dbus_connection_call() with the
* client's #GMainContext, so that the response is always in order with other
* events D-Bus events. Of course, the call uses #GTask and will invoke the
* callback on the current g_main_context_get_thread_default().
*
* This API is merely a convenient wrapper for g_dbus_connection_call(). You can
* also use g_dbus_connection_call() directly, with the same effect.
* @param object_path path of remote object
* @param interface_name D-Bus interface to invoke method on
* @param method_name the name of the method to invoke
* @param parameters a #GVariant tuple with parameters for the method or %NULL if not passing parameters
* @param reply_type the expected type of the reply (which will be a tuple), or %NULL
* @param timeout_msec the timeout in milliseconds, -1 to use the default timeout or %G_MAXINT for no timeout
* @param cancellable a #GCancellable or %NULL
*/
dbus_call(
object_path: string,
interface_name: string,
method_name: string,
parameters: GLib.Variant | null,
reply_type: GLib.VariantType | null,
timeout_msec: number,
cancellable?: Gio.Cancellable | null,
): Promise;
/**
* Call g_dbus_connection_call() on the current name owner with the specified
* arguments. Most importantly, this invokes g_dbus_connection_call() with the
* client's #GMainContext, so that the response is always in order with other
* events D-Bus events. Of course, the call uses #GTask and will invoke the
* callback on the current g_main_context_get_thread_default().
*
* This API is merely a convenient wrapper for g_dbus_connection_call(). You can
* also use g_dbus_connection_call() directly, with the same effect.
* @param object_path path of remote object
* @param interface_name D-Bus interface to invoke method on
* @param method_name the name of the method to invoke
* @param parameters a #GVariant tuple with parameters for the method or %NULL if not passing parameters
* @param reply_type the expected type of the reply (which will be a tuple), or %NULL
* @param timeout_msec the timeout in milliseconds, -1 to use the default timeout or %G_MAXINT for no timeout
* @param cancellable a #GCancellable or %NULL
* @param callback a #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result of the method invocation
*/
dbus_call(
object_path: string,
interface_name: string,
method_name: string,
parameters: GLib.Variant | null,
reply_type: GLib.VariantType | null,
timeout_msec: number,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback | null,
): void;
/**
* Call g_dbus_connection_call() on the current name owner with the specified
* arguments. Most importantly, this invokes g_dbus_connection_call() with the
* client's #GMainContext, so that the response is always in order with other
* events D-Bus events. Of course, the call uses #GTask and will invoke the
* callback on the current g_main_context_get_thread_default().
*
* This API is merely a convenient wrapper for g_dbus_connection_call(). You can
* also use g_dbus_connection_call() directly, with the same effect.
* @param object_path path of remote object
* @param interface_name D-Bus interface to invoke method on
* @param method_name the name of the method to invoke
* @param parameters a #GVariant tuple with parameters for the method or %NULL if not passing parameters
* @param reply_type the expected type of the reply (which will be a tuple), or %NULL
* @param timeout_msec the timeout in milliseconds, -1 to use the default timeout or %G_MAXINT for no timeout
* @param cancellable a #GCancellable or %NULL
* @param callback a #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result of the method invocation
*/
dbus_call(
object_path: string,
interface_name: string,
method_name: string,
parameters: GLib.Variant | null,
reply_type: GLib.VariantType | null,
timeout_msec: number,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise | void;
/**
* Gets the result of a call to nm_client_dbus_call().
* @param result the result passed to the #GAsyncReadyCallback
* @returns the result #GVariant or %NULL on error.
*/
dbus_call_finish(result: Gio.AsyncResult): GLib.Variant;
/**
* Like nm_client_dbus_call() but calls "Set" on the standard "org.freedesktop.DBus.Properties"
* D-Bus interface.
* @param object_path path of remote object
* @param interface_name D-Bus interface for the property to set.
* @param property_name the name of the property to set
* @param value a #GVariant with the value to set.
* @param timeout_msec the timeout in milliseconds, -1 to use the default timeout or %G_MAXINT for no timeout
* @param cancellable a #GCancellable or %NULL
*/
dbus_set_property(
object_path: string,
interface_name: string,
property_name: string,
value: GLib.Variant,
timeout_msec: number,
cancellable?: Gio.Cancellable | null,
): Promise;
/**
* Like nm_client_dbus_call() but calls "Set" on the standard "org.freedesktop.DBus.Properties"
* D-Bus interface.
* @param object_path path of remote object
* @param interface_name D-Bus interface for the property to set.
* @param property_name the name of the property to set
* @param value a #GVariant with the value to set.
* @param timeout_msec the timeout in milliseconds, -1 to use the default timeout or %G_MAXINT for no timeout
* @param cancellable a #GCancellable or %NULL
* @param callback a #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result of the method invocation
*/
dbus_set_property(
object_path: string,
interface_name: string,
property_name: string,
value: GLib.Variant,
timeout_msec: number,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback | null,
): void;
/**
* Like nm_client_dbus_call() but calls "Set" on the standard "org.freedesktop.DBus.Properties"
* D-Bus interface.
* @param object_path path of remote object
* @param interface_name D-Bus interface for the property to set.
* @param property_name the name of the property to set
* @param value a #GVariant with the value to set.
* @param timeout_msec the timeout in milliseconds, -1 to use the default timeout or %G_MAXINT for no timeout
* @param cancellable a #GCancellable or %NULL
* @param callback a #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result of the method invocation
*/
dbus_set_property(
object_path: string,
interface_name: string,
property_name: string,
value: GLib.Variant,
timeout_msec: number,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise | void;
/**
* Gets the result of a call to nm_client_dbus_set_property().
* @param result the result passed to the #GAsyncReadyCallback
* @returns %TRUE on success or %FALSE on failure.
*/
dbus_set_property_finish(result: Gio.AsyncResult): boolean;
/**
* Deactivates an active #NMActiveConnection.
* @param active the #NMActiveConnection to deactivate
* @param cancellable a #GCancellable, or %NULL
* @returns success or failure
*/
deactivate_connection(active: ActiveConnection, cancellable?: Gio.Cancellable | null): boolean;
/**
* Asynchronously deactivates an active #NMActiveConnection.
* @param active the #NMActiveConnection to deactivate
* @param cancellable a #GCancellable, or %NULL
*/
deactivate_connection_async(
active: ActiveConnection,
cancellable?: Gio.Cancellable | null,
): Promise;
/**
* Asynchronously deactivates an active #NMActiveConnection.
* @param active the #NMActiveConnection to deactivate
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the deactivation has completed
*/
deactivate_connection_async(
active: ActiveConnection,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback | null,
): void;
/**
* Asynchronously deactivates an active #NMActiveConnection.
* @param active the #NMActiveConnection to deactivate
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the deactivation has completed
*/
deactivate_connection_async(
active: ActiveConnection,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise | void;
/**
* Gets the result of a call to nm_client_deactivate_connection_async().
* @param result the result passed to the #GAsyncReadyCallback
* @returns success or failure
*/
deactivate_connection_finish(result: Gio.AsyncResult): boolean;
/**
* Gets the #NMActiveConnection corresponding to a
* currently-activating connection that is expected to become the new
* #NMClient:primary-connection upon successful activation.
* @returns the appropriate #NMActiveConnection, if any.
*/
get_activating_connection(): ActiveConnection;
/**
* Gets the active connections.
* @returns a #GPtrArray containing all the active #NMActiveConnections. The returned array is owned by the client and should not be modified.
*/
get_active_connections(): ActiveConnection[];
/**
* Gets both real devices and device placeholders (eg, software devices which
* do not currently exist, but could be created automatically by NetworkManager
* if one of their NMDevice::ActivatableConnections was activated). Use
* nm_device_is_real() to determine whether each device is a real device or
* a placeholder.
*
* Use nm_device_get_type() or the NM_IS_DEVICE_XXXX() functions to determine
* what kind of device each member of the returned array is, and then you may
* use device-specific methods such as nm_device_ethernet_get_hw_address().
* @returns a #GPtrArray containing all the #NMDevices. The returned array is owned by the #NMClient object and should not be modified.
*/
get_all_devices(): Device[];
get_capabilities(): number[];
/**
* Gets all the active checkpoints.
* @returns a #GPtrArray containing all the #NMCheckpoint. The returned array is owned by the #NMClient object and should not be modified.
*/
get_checkpoints(): Checkpoint[];
/**
* Returns the first matching %NMRemoteConnection matching a given `id`.
* @param id the id of the remote connection
* @returns the remote connection object on success, or %NULL if no matching object was found. The connection is as received from D-Bus and might not validate according to nm_connection_verify().
*/
get_connection_by_id(id: string): RemoteConnection;
/**
* Returns the %NMRemoteConnection representing the connection at `path`.
* @param path the D-Bus object path of the remote connection
* @returns the remote connection object on success, or %NULL if the object was not known The connection is as received from D-Bus and might not validate according to nm_connection_verify().
*/
get_connection_by_path(path: string): RemoteConnection;
/**
* Returns the %NMRemoteConnection identified by `uuid`.
* @param uuid the UUID of the remote connection
* @returns the remote connection object on success, or %NULL if the object was not known The connection is as received from D-Bus and might not validate according to nm_connection_verify().
*/
get_connection_by_uuid(uuid: string): RemoteConnection;
get_connections(): RemoteConnection[];
/**
* Gets the current network connectivity state. Contrast
* nm_client_check_connectivity() and
* nm_client_check_connectivity_async(), which re-check the
* connectivity state first before returning any information.
* @returns the current connectivity state
*/
get_connectivity(): ConnectivityState;
get_context_busy_watcher(): T;
/**
* Gets the %GDBusConnection of the instance. This can be either passed when
* constructing the instance (as "dbus-connection" property), or it will be
* automatically initialized during async/sync init.
* @returns the D-Bus connection of the client, or %NULL if none is set.
*/
get_dbus_connection(): Gio.DBusConnection;
get_dbus_name_owner(): string;
/**
* Gets a #NMDevice from a #NMClient.
* @param iface the interface name to search for
* @returns the #NMDevice for the given @iface or %NULL if none is found.
*/
get_device_by_iface(iface: string): Device;
/**
* Gets a #NMDevice from a #NMClient.
* @param object_path the object path to search for
* @returns the #NMDevice for the given @object_path or %NULL if none is found.
*/
get_device_by_path(object_path: string): Device;
/**
* Gets all the known network devices. Use nm_device_get_type() or the
* NM_IS_DEVICE_XXXX functions to determine what kind of
* device member of the returned array is, and then you may use device-specific
* methods such as nm_device_ethernet_get_hw_address().
* @returns a #GPtrArray containing all the #NMDevices. The returned array is owned by the #NMClient object and should not be modified.
*/
get_devices(): Device[];
/**
* Gets the current DNS configuration
* @returns a #GPtrArray containing #NMDnsEntry elements or %NULL in case the value is not available. The returned array is owned by the #NMClient object and should not be modified.
*/
get_dns_configuration(): DnsEntry[];
/**
* Gets the current DNS processing mode.
* @returns the DNS processing mode, or %NULL in case the value is not available.
*/
get_dns_mode(): string;
/**
* Gets the current DNS resolv.conf manager.
* @returns the resolv.conf manager or %NULL in case the value is not available.
*/
get_dns_rc_manager(): string;
get_instance_flags(): ClientInstanceFlags;
/**
* Gets NetworkManager current logging level and domains.
* @returns %TRUE on success, %FALSE otherwise
*/
get_logging(): [boolean, string, string];
/**
* The #NMClient instance is permanently associated with the current
* thread default #GMainContext, referenced the time when the instance
* was created. To receive events, the user must iterate this context
* and can use it to synchronize access to the client.
*
* Note that even after #NMClient instance got destroyed, there might
* still be pending sources registered in the context. That means, to fully
* clean up, the user must continue iterating the context as long as
* the nm_client_get_context_busy_watcher() object is alive.
* @returns the #GMainContext of the client.
*/
get_main_context(): GLib.MainContext;
get_metered(): Metered;
/**
* Determines whether the daemon is running.
* @returns %TRUE if the daemon is running
*/
get_nm_running(): boolean;
get_object_by_path(dbus_path: string): Object;
/**
* Requests the result of a specific permission, which indicates whether the
* client can or cannot perform the action the permission represents
* @param permission the permission for which to return the result, one of #NMClientPermission
* @returns the permission's result, one of #NMClientPermissionResult
*/
get_permission_result(permission: ClientPermission | null): ClientPermissionResult;
get_permissions_state(): Ternary;
/**
* Gets the #NMActiveConnection corresponding to the primary active
* network device.
*
* In particular, when there is no VPN active, or the VPN does not
* have the default route, this returns the active connection that has
* the default route. If there is a VPN active with the default route,
* then this function returns the active connection that contains the
* route to the VPN endpoint.
*
* If there is no default route, or the default route is over a
* non-NetworkManager-recognized device, this will return %NULL.
* @returns the appropriate #NMActiveConnection, if any
*/
get_primary_connection(): ActiveConnection;
/**
* Get radio flags.
* @returns the #NMRadioFlags.
*/
get_radio_flags(): RadioFlags;
/**
* Tests whether the daemon is still in the process of activating
* connections at startup.
* @returns whether the daemon is still starting up
*/
get_startup(): boolean;
/**
* Gets the current daemon state.
* @returns the current %NMState
*/
get_state(): State;
/**
* Gets NetworkManager version.
* @returns string with the version (or %NULL if NetworkManager is not running)
*/
get_version(): string;
/**
* If available, the first element in the array is NM_VERSION which
* encodes the daemon version as "(major << 16 | minor << 8 | micro)".
* The following elements are a bitfield of %NMVersionInfoCapability
* that indicate that the daemon supports a certain capability.
* @returns the list of capabilities reported by the server or %NULL if the capabilities are unknown.
*/
get_version_info(): number[];
/**
* Requests that the remote settings service load or reload the given files,
* adding or updating the connections described within.
*
* The changes to the indicated files will not yet be reflected in
* `client'`s connections array when the function returns.
*
* If all of the indicated files were successfully loaded, the
* function will return %TRUE, and `failures` will be set to %NULL. If
* NetworkManager tried to load the files, but some (or all) failed,
* then `failures` will be set to a %NULL-terminated array of the
* filenames that failed to load.
* @param filenames %NULL-terminated array of filenames to load
* @param cancellable a #GCancellable, or %NULL
* @returns %TRUE on success. Warning: before libnm 1.22, the boolean return value was inconsistent. That is made worse, because when running against certain server versions before 1.20, the server would return wrong values for success/failure. This means, if you use this function in libnm before 1.22, you are advised to ignore the boolean return value and only look at @failures and @error. With libnm >= 1.22, the boolean return value corresponds to whether @error was set. Note that even in the success case, you might have individual @failures. With 1.22, the return value is consistent with nm_client_load_connections_finish().
*/
load_connections(filenames: string[], cancellable?: Gio.Cancellable | null): [boolean, string];
/**
* Requests that the remote settings service asynchronously load or reload the
* given files, adding or updating the connections described within.
*
* See nm_client_load_connections() for more details.
* @param filenames %NULL-terminated array of filenames to load
* @param cancellable a #GCancellable, or %NULL
*/
load_connections_async(filenames: string[], cancellable?: Gio.Cancellable | null): Promise;
/**
* Requests that the remote settings service asynchronously load or reload the
* given files, adding or updating the connections described within.
*
* See nm_client_load_connections() for more details.
* @param filenames %NULL-terminated array of filenames to load
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the operation completes
*/
load_connections_async(
filenames: string[],
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback | null,
): void;
/**
* Requests that the remote settings service asynchronously load or reload the
* given files, adding or updating the connections described within.
*
* See nm_client_load_connections() for more details.
* @param filenames %NULL-terminated array of filenames to load
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the operation completes
*/
load_connections_async(
filenames: string[],
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise | void;
/**
* Gets the result of an nm_client_load_connections_async() call.
*
* See nm_client_load_connections() for more details.
* @param result the result passed to the #GAsyncReadyCallback
* @returns %TRUE on success. Note that even in the success case, you might have individual @failures.
*/
load_connections_finish(result: Gio.AsyncResult): [boolean, string[]];
/**
* Whether networking is enabled or disabled.
* @returns %TRUE if networking is enabled, %FALSE if networking is disabled
*/
networking_get_enabled(): boolean;
/**
* Enables or disables networking. When networking is disabled, all controlled
* interfaces are disconnected and deactivated. When networking is enabled,
* all controlled interfaces are available for activation.
* @param enabled %TRUE to set networking enabled, %FALSE to set networking disabled
* @returns %TRUE on success, %FALSE otherwise
*/
networking_set_enabled(enabled: boolean): boolean;
/**
* Reload NetworkManager's configuration and perform certain updates, like
* flushing caches or rewriting external state to disk. This is similar to
* sending SIGHUP to NetworkManager but it allows for more fine-grained control
* over what to reload (see `flags)`. It also allows non-root access via
* PolicyKit and contrary to signals it is synchronous.
* @param flags flags indicating what to reload.
* @param cancellable a #GCancellable, or %NULL
*/
reload(flags: ManagerReloadFlags | null, cancellable?: Gio.Cancellable | null): Promise;
/**
* Reload NetworkManager's configuration and perform certain updates, like
* flushing caches or rewriting external state to disk. This is similar to
* sending SIGHUP to NetworkManager but it allows for more fine-grained control
* over what to reload (see `flags)`. It also allows non-root access via
* PolicyKit and contrary to signals it is synchronous.
* @param flags flags indicating what to reload.
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the add operation completes
*/
reload(
flags: ManagerReloadFlags | null,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback | null,
): void;
/**
* Reload NetworkManager's configuration and perform certain updates, like
* flushing caches or rewriting external state to disk. This is similar to
* sending SIGHUP to NetworkManager but it allows for more fine-grained control
* over what to reload (see `flags)`. It also allows non-root access via
* PolicyKit and contrary to signals it is synchronous.
* @param flags flags indicating what to reload.
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the add operation completes
*/
reload(
flags: ManagerReloadFlags | null,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise | void;
/**
* Requests that the remote settings service reload all connection
* files from disk, adding, updating, and removing connections until
* the in-memory state matches the on-disk state.
* @param cancellable a #GCancellable, or %NULL
* @returns %TRUE on success, %FALSE on failure
*/
reload_connections(cancellable?: Gio.Cancellable | null): boolean;
/**
* Requests that the remote settings service begin reloading all connection
* files from disk, adding, updating, and removing connections until the
* in-memory state matches the on-disk state.
* @param cancellable a #GCancellable, or %NULL
*/
reload_connections_async(cancellable?: Gio.Cancellable | null): Promise;
/**
* Requests that the remote settings service begin reloading all connection
* files from disk, adding, updating, and removing connections until the
* in-memory state matches the on-disk state.
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the reload operation completes
*/
reload_connections_async(
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback | null,
): void;
/**
* Requests that the remote settings service begin reloading all connection
* files from disk, adding, updating, and removing connections until the
* in-memory state matches the on-disk state.
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the reload operation completes
*/
reload_connections_async(
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise | void;
/**
* Gets the result of an nm_client_reload_connections_async() call.
* @param result the result passed to the #GAsyncReadyCallback
* @returns %TRUE on success, %FALSE on failure
*/
reload_connections_finish(result: Gio.AsyncResult): boolean;
/**
* Gets the result of a call to nm_client_reload().
* @param result the result passed to the #GAsyncReadyCallback
* @returns %TRUE on success or %FALSE on failure.
*/
reload_finish(result: Gio.AsyncResult): boolean;
/**
* Requests that the machine's persistent hostname be set to the specified value
* or cleared.
* @param hostname the new persistent hostname to set, or %NULL to clear any existing persistent hostname
* @param cancellable a #GCancellable, or %NULL
* @returns %TRUE if the request was successful, %FALSE if it failed
*/
save_hostname(hostname?: string | null, cancellable?: Gio.Cancellable | null): boolean;
/**
* Requests that the machine's persistent hostname be set to the specified value
* or cleared.
* @param hostname the new persistent hostname to set, or %NULL to clear any existing persistent hostname
* @param cancellable a #GCancellable, or %NULL
*/
save_hostname_async(hostname?: string | null, cancellable?: Gio.Cancellable | null): Promise;
/**
* Requests that the machine's persistent hostname be set to the specified value
* or cleared.
* @param hostname the new persistent hostname to set, or %NULL to clear any existing persistent hostname
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the operation completes
*/
save_hostname_async(
hostname: string | null,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback | null,
): void;
/**
* Requests that the machine's persistent hostname be set to the specified value
* or cleared.
* @param hostname the new persistent hostname to set, or %NULL to clear any existing persistent hostname
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the operation completes
*/
save_hostname_async(
hostname?: string | null,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise | void;
/**
* Gets the result of an nm_client_save_hostname_async() call.
* @param result the result passed to the #GAsyncReadyCallback
* @returns %TRUE if the request was successful, %FALSE if it failed
*/
save_hostname_finish(result: Gio.AsyncResult): boolean;
/**
* Sets NetworkManager logging level and/or domains.
* @param level logging level to set (%NULL or an empty string for no change)
* @param domains logging domains to set. The string should be a list of log domains separated by ",". (%NULL or an empty string for no change)
* @returns %TRUE on success, %FALSE otherwise
*/
set_logging(level?: string | null, domains?: string | null): boolean;
/**
* The way to stop #NMClient is by unrefing it. That will cancel all
* internally pending async operations. However, as async operations in
* NMClient use GTask, hence they cannot complete right away. Instead,
* their (internal) result callback still needs to be dispatched by iterating
* the client's main context.
*
* You thus cannot stop iterating the client's main context until
* everything is wrapped up. nm_client_get_context_busy_watcher()
* helps to watch how long that will be.
*
* This function automates that waiting. Like all glib async operations
* this honors the current g_main_context_get_thread_default().
*
* In any case, to complete the shutdown, nm_client_get_main_context()
* must be iterated. If the current g_main_context_get_thread_default() is
* the same as nm_client_get_main_context(), then `integrate_maincontext`
* is ignored. In that case, the caller is required to iterate the context
* for shutdown to complete. Otherwise, if g_main_context_get_thread_default()
* differs from nm_client_get_main_context() and `integrate_maincontext`
* is %FALSE, the caller must make sure that both contexts are iterated
* until completion. Otherwise, if `integrate_maincontext` is %TRUE, then
* nm_client_get_main_context() will be integrated in g_main_context_get_thread_default().
* This means, the caller gives nm_client_get_main_context() up until the waiting
* completes, the function will acquire the context and hook it into
* g_main_context_get_thread_default().
* It is a bug to request `integrate_maincontext` while having nm_client_get_main_context()
* acquired or iterated otherwise because a context can only be acquired once
* at a time.
*
* Shutdown can only complete after all references to `client` were released.
*
* It is possible to call this function multiple times for the same client.
* But note that with `integrate_maincontext` the client's context is acquired,
* which can only be done once at a time.
*
* It is permissible to start waiting before the objects is fully initialized.
*
* The function really allows two separate things. To get a notification (callback) when
* shutdown is complete, and to integrate the client's context in another context.
* The latter case is useful if the client has a separate context and you hand it
* over to another GMainContext to wrap up.
*
* The main use is to have a NMClient and a separate GMainContext on a worker
* thread. When being done, you can hand over the cleanup of the context
* to g_main_context_default(), assuming that the main thread iterates
* the default context. In that case, you don't need to care about passing
* a callback to know when shutdown completed.
* @param integrate_maincontext whether to hook the client's maincontext in the current thread default. Otherwise, you must ensure that the client's maincontext gets iterated so that it can complete. By integrating the maincontext in the current thread default, you may instead only iterate the latter.
* @param cancellable the #GCancellable to abort the shutdown.
* @param callback a #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result of the method invocation.
*/
wait_shutdown(
integrate_maincontext: boolean,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): void;
/**
* Determines whether WiMAX is enabled.
* @returns %TRUE if WiMAX is enabled
*/
wimax_get_enabled(): boolean;
/**
* Determines whether the WiMAX hardware is enabled.
* @returns %TRUE if the WiMAX hardware is enabled
*/
wimax_hardware_get_enabled(): boolean;
/**
* Enables or disables WiMAX devices.
* @param enabled %TRUE to enable WiMAX
*/
wimax_set_enabled(enabled: boolean): void;
/**
* Determines whether the wireless is enabled.
* @returns %TRUE if wireless is enabled
*/
wireless_get_enabled(): boolean;
/**
* Determines whether the wireless hardware is enabled.
* @returns %TRUE if the wireless hardware is enabled
*/
wireless_hardware_get_enabled(): boolean;
/**
* Enables or disables wireless devices.
* @param enabled %TRUE to enable wireless
*/
wireless_set_enabled(enabled: boolean): void;
/**
* Determines whether WWAN is enabled.
* @returns %TRUE if WWAN is enabled
*/
wwan_get_enabled(): boolean;
/**
* Determines whether the WWAN hardware is enabled.
* @returns %TRUE if the WWAN hardware is enabled
*/
wwan_hardware_get_enabled(): boolean;
/**
* Enables or disables WWAN devices.
* @param enabled %TRUE to enable WWAN
*/
wwan_set_enabled(enabled: boolean): void;
// Inherited methods
/**
* Starts asynchronous initialization of the object implementing the
* interface. This must be done before any real use of the object after
* initial construction. If the object also implements #GInitable you can
* optionally call g_initable_init() instead.
*
* This method is intended for language bindings. If writing in C,
* g_async_initable_new_async() should typically be used instead.
*
* When the initialization is finished, `callback` will be called. You can
* then call g_async_initable_init_finish() to get the result of the
* initialization.
*
* Implementations may also support cancellation. If `cancellable` is not
* %NULL, then initialization can be cancelled by triggering the cancellable
* object from another thread. If the operation was cancelled, the error
* %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
* the object doesn't support cancellable initialization, the error
* %G_IO_ERROR_NOT_SUPPORTED will be returned.
*
* As with #GInitable, if the object is not initialized, or initialization
* returns with an error, then all operations on the object except
* g_object_ref() and g_object_unref() are considered to be invalid, and
* have undefined behaviour. They will often fail with g_critical() or
* g_warning(), but this must not be relied on.
*
* Callers should not assume that a class which implements #GAsyncInitable can
* be initialized multiple times; for more information, see g_initable_init().
* If a class explicitly supports being initialized multiple times,
* implementation requires yielding all subsequent calls to init_async() on the
* results of the first call.
*
* For classes that also support the #GInitable interface, the default
* implementation of this method will run the g_initable_init() function
* in a thread, so if you want to support asynchronous initialization via
* threads, just implement the #GAsyncInitable interface without overriding
* any interface methods.
* @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
* @param cancellable optional #GCancellable object, %NULL to ignore.
*/
init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise;
/**
* Starts asynchronous initialization of the object implementing the
* interface. This must be done before any real use of the object after
* initial construction. If the object also implements #GInitable you can
* optionally call g_initable_init() instead.
*
* This method is intended for language bindings. If writing in C,
* g_async_initable_new_async() should typically be used instead.
*
* When the initialization is finished, `callback` will be called. You can
* then call g_async_initable_init_finish() to get the result of the
* initialization.
*
* Implementations may also support cancellation. If `cancellable` is not
* %NULL, then initialization can be cancelled by triggering the cancellable
* object from another thread. If the operation was cancelled, the error
* %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
* the object doesn't support cancellable initialization, the error
* %G_IO_ERROR_NOT_SUPPORTED will be returned.
*
* As with #GInitable, if the object is not initialized, or initialization
* returns with an error, then all operations on the object except
* g_object_ref() and g_object_unref() are considered to be invalid, and
* have undefined behaviour. They will often fail with g_critical() or
* g_warning(), but this must not be relied on.
*
* Callers should not assume that a class which implements #GAsyncInitable can
* be initialized multiple times; for more information, see g_initable_init().
* If a class explicitly supports being initialized multiple times,
* implementation requires yielding all subsequent calls to init_async() on the
* results of the first call.
*
* For classes that also support the #GInitable interface, the default
* implementation of this method will run the g_initable_init() function
* in a thread, so if you want to support asynchronous initialization via
* threads, just implement the #GAsyncInitable interface without overriding
* any interface methods.
* @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
* @param cancellable optional #GCancellable object, %NULL to ignore.
* @param callback a #GAsyncReadyCallback to call when the request is satisfied
*/
init_async(
io_priority: number,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback | null,
): void;
/**
* Starts asynchronous initialization of the object implementing the
* interface. This must be done before any real use of the object after
* initial construction. If the object also implements #GInitable you can
* optionally call g_initable_init() instead.
*
* This method is intended for language bindings. If writing in C,
* g_async_initable_new_async() should typically be used instead.
*
* When the initialization is finished, `callback` will be called. You can
* then call g_async_initable_init_finish() to get the result of the
* initialization.
*
* Implementations may also support cancellation. If `cancellable` is not
* %NULL, then initialization can be cancelled by triggering the cancellable
* object from another thread. If the operation was cancelled, the error
* %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
* the object doesn't support cancellable initialization, the error
* %G_IO_ERROR_NOT_SUPPORTED will be returned.
*
* As with #GInitable, if the object is not initialized, or initialization
* returns with an error, then all operations on the object except
* g_object_ref() and g_object_unref() are considered to be invalid, and
* have undefined behaviour. They will often fail with g_critical() or
* g_warning(), but this must not be relied on.
*
* Callers should not assume that a class which implements #GAsyncInitable can
* be initialized multiple times; for more information, see g_initable_init().
* If a class explicitly supports being initialized multiple times,
* implementation requires yielding all subsequent calls to init_async() on the
* results of the first call.
*
* For classes that also support the #GInitable interface, the default
* implementation of this method will run the g_initable_init() function
* in a thread, so if you want to support asynchronous initialization via
* threads, just implement the #GAsyncInitable interface without overriding
* any interface methods.
* @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
* @param cancellable optional #GCancellable object, %NULL to ignore.
* @param callback a #GAsyncReadyCallback to call when the request is satisfied
*/
init_async(
io_priority: number,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise | void;
/**
* Finishes asynchronous initialization and returns the result.
* See g_async_initable_init_async().
* @param res a #GAsyncResult.
* @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
*/
init_finish(res: Gio.AsyncResult): boolean;
/**
* Finishes the async construction for the various g_async_initable_new
* calls, returning the created object or %NULL on error.
* @param res the #GAsyncResult from the callback
* @returns a newly created #GObject, or %NULL on error. Free with g_object_unref().
*/
new_finish(res: Gio.AsyncResult): Client;
/**
* Starts asynchronous initialization of the object implementing the
* interface. This must be done before any real use of the object after
* initial construction. If the object also implements #GInitable you can
* optionally call g_initable_init() instead.
*
* This method is intended for language bindings. If writing in C,
* g_async_initable_new_async() should typically be used instead.
*
* When the initialization is finished, `callback` will be called. You can
* then call g_async_initable_init_finish() to get the result of the
* initialization.
*
* Implementations may also support cancellation. If `cancellable` is not
* %NULL, then initialization can be cancelled by triggering the cancellable
* object from another thread. If the operation was cancelled, the error
* %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
* the object doesn't support cancellable initialization, the error
* %G_IO_ERROR_NOT_SUPPORTED will be returned.
*
* As with #GInitable, if the object is not initialized, or initialization
* returns with an error, then all operations on the object except
* g_object_ref() and g_object_unref() are considered to be invalid, and
* have undefined behaviour. They will often fail with g_critical() or
* g_warning(), but this must not be relied on.
*
* Callers should not assume that a class which implements #GAsyncInitable can
* be initialized multiple times; for more information, see g_initable_init().
* If a class explicitly supports being initialized multiple times,
* implementation requires yielding all subsequent calls to init_async() on the
* results of the first call.
*
* For classes that also support the #GInitable interface, the default
* implementation of this method will run the g_initable_init() function
* in a thread, so if you want to support asynchronous initialization via
* threads, just implement the #GAsyncInitable interface without overriding
* any interface methods.
* @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
* @param cancellable optional #GCancellable object, %NULL to ignore.
* @param callback a #GAsyncReadyCallback to call when the request is satisfied
*/
vfunc_init_async(
io_priority: number,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): void;
/**
* Finishes asynchronous initialization and returns the result.
* See g_async_initable_init_async().
* @param res a #GAsyncResult.
*/
vfunc_init_finish(res: Gio.AsyncResult): boolean;
/**
* Initializes the object implementing the interface.
*
* This method is intended for language bindings. If writing in C,
* g_initable_new() should typically be used instead.
*
* The object must be initialized before any real use after initial
* construction, either with this function or g_async_initable_init_async().
*
* Implementations may also support cancellation. If `cancellable` is not %NULL,
* then initialization can be cancelled by triggering the cancellable object
* from another thread. If the operation was cancelled, the error
* %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
* the object doesn't support cancellable initialization the error
* %G_IO_ERROR_NOT_SUPPORTED will be returned.
*
* If the object is not initialized, or initialization returns with an
* error, then all operations on the object except g_object_ref() and
* g_object_unref() are considered to be invalid, and have undefined
* behaviour. See the [description][iface`Gio`.Initable#description] for more details.
*
* Callers should not assume that a class which implements #GInitable can be
* initialized multiple times, unless the class explicitly documents itself as
* supporting this. Generally, a class’ implementation of init() can assume
* (and assert) that it will only be called once. Previously, this documentation
* recommended all #GInitable implementations should be idempotent; that
* recommendation was relaxed in GLib 2.54.
*
* If a class explicitly supports being initialized multiple times, it is
* recommended that the method is idempotent: multiple calls with the same
* arguments should return the same results. Only the first call initializes
* the object; further calls return the result of the first call.
*
* One reason why a class might need to support idempotent initialization is if
* it is designed to be used via the singleton pattern, with a
* #GObjectClass.constructor that sometimes returns an existing instance.
* In this pattern, a caller would expect to be able to call g_initable_init()
* on the result of g_object_new(), regardless of whether it is in fact a new
* instance.
* @param cancellable optional #GCancellable object, %NULL to ignore.
* @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
*/
init(cancellable?: Gio.Cancellable | null): boolean;
/**
* Initializes the object implementing the interface.
*
* This method is intended for language bindings. If writing in C,
* g_initable_new() should typically be used instead.
*
* The object must be initialized before any real use after initial
* construction, either with this function or g_async_initable_init_async().
*
* Implementations may also support cancellation. If `cancellable` is not %NULL,
* then initialization can be cancelled by triggering the cancellable object
* from another thread. If the operation was cancelled, the error
* %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
* the object doesn't support cancellable initialization the error
* %G_IO_ERROR_NOT_SUPPORTED will be returned.
*
* If the object is not initialized, or initialization returns with an
* error, then all operations on the object except g_object_ref() and
* g_object_unref() are considered to be invalid, and have undefined
* behaviour. See the [description][iface`Gio`.Initable#description] for more details.
*
* Callers should not assume that a class which implements #GInitable can be
* initialized multiple times, unless the class explicitly documents itself as
* supporting this. Generally, a class’ implementation of init() can assume
* (and assert) that it will only be called once. Previously, this documentation
* recommended all #GInitable implementations should be idempotent; that
* recommendation was relaxed in GLib 2.54.
*
* If a class explicitly supports being initialized multiple times, it is
* recommended that the method is idempotent: multiple calls with the same
* arguments should return the same results. Only the first call initializes
* the object; further calls return the result of the first call.
*
* One reason why a class might need to support idempotent initialization is if
* it is designed to be used via the singleton pattern, with a
* #GObjectClass.constructor that sometimes returns an existing instance.
* In this pattern, a caller would expect to be able to call g_initable_init()
* on the result of g_object_new(), regardless of whether it is in fact a new
* instance.
* @param cancellable optional #GCancellable object, %NULL to ignore.
*/
vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
/**
* Creates a binding between `source_property` on `source` and `target_property`
* on `target`.
*
* Whenever the `source_property` is changed the `target_property` is
* updated using the same value. For instance:
*
*
* ```c
* g_object_bind_property (action, "active", widget, "sensitive", 0);
* ```
*
*
* Will result in the "sensitive" property of the widget #GObject instance to be
* updated with the same value of the "active" property of the action #GObject
* instance.
*
* If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
* if `target_property` on `target` changes then the `source_property` on `source`
* will be updated as well.
*
* The binding will automatically be removed when either the `source` or the
* `target` instances are finalized. To remove the binding without affecting the
* `source` and the `target` you can just call g_object_unref() on the returned
* #GBinding instance.
*
* Removing the binding by calling g_object_unref() on it must only be done if
* the binding, `source` and `target` are only used from a single thread and it
* is clear that both `source` and `target` outlive the binding. Especially it
* is not safe to rely on this if the binding, `source` or `target` can be
* finalized from different threads. Keep another reference to the binding and
* use g_binding_unbind() instead to be on the safe side.
*
* A #GObject can have multiple bindings.
* @param source_property the property on @source to bind
* @param target the target #GObject
* @param target_property the property on @target to bind
* @param flags flags to pass to #GBinding
* @returns the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero.
*/
bind_property(
source_property: string,
target: GObject.Object,
target_property: string,
flags: GObject.BindingFlags | null,
): GObject.Binding;
/**
* Complete version of g_object_bind_property().
*
* Creates a binding between `source_property` on `source` and `target_property`
* on `target,` allowing you to set the transformation functions to be used by
* the binding.
*
* If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
* if `target_property` on `target` changes then the `source_property` on `source`
* will be updated as well. The `transform_from` function is only used in case
* of bidirectional bindings, otherwise it will be ignored
*
* The binding will automatically be removed when either the `source` or the
* `target` instances are finalized. This will release the reference that is
* being held on the #GBinding instance; if you want to hold on to the
* #GBinding instance, you will need to hold a reference to it.
*
* To remove the binding, call g_binding_unbind().
*
* A #GObject can have multiple bindings.
*
* The same `user_data` parameter will be used for both `transform_to`
* and `transform_from` transformation functions; the `notify` function will
* be called once, when the binding is removed. If you need different data
* for each transformation function, please use
* g_object_bind_property_with_closures() instead.
* @param source_property the property on @source to bind
* @param target the target #GObject
* @param target_property the property on @target to bind
* @param flags flags to pass to #GBinding
* @param transform_to the transformation function from the @source to the @target, or %NULL to use the default
* @param transform_from the transformation function from the @target to the @source, or %NULL to use the default
* @param notify a function to call when disposing the binding, to free resources used by the transformation functions, or %NULL if not required
* @returns the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero.
*/
bind_property_full(
source_property: string,
target: GObject.Object,
target_property: string,
flags: GObject.BindingFlags | null,
transform_to?: GObject.BindingTransformFunc | null,
transform_from?: GObject.BindingTransformFunc | null,
notify?: GLib.DestroyNotify | null,
): GObject.Binding;
// Conflicted with GObject.Object.bind_property_full
bind_property_full(...args: never[]): any;
/**
* This function is intended for #GObject implementations to re-enforce
* a [floating][floating-ref] object reference. Doing this is seldom
* required: all #GInitiallyUnowneds are created with a floating reference
* which usually just needs to be sunken by calling g_object_ref_sink().
*/
force_floating(): void;
/**
* Increases the freeze count on `object`. If the freeze count is
* non-zero, the emission of "notify" signals on `object` is
* stopped. The signals are queued until the freeze count is decreased
* to zero. Duplicate notifications are squashed so that at most one
* #GObject::notify signal is emitted for each property modified while the
* object is frozen.
*
* This is necessary for accessors that modify multiple properties to prevent
* premature notification while the object is still being modified.
*/
freeze_notify(): void;
/**
* Gets a named field from the objects table of associations (see g_object_set_data()).
* @param key name of the key for that association
* @returns the data if found, or %NULL if no such data exists.
*/
get_data(key: string): any | null;
/**
* Gets a property of an object.
*
* The value can be:
* - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
* - a GObject.Value initialized with the expected type of the property
* - a GObject.Value initialized with a type to which the expected type of the property can be transformed
*
* In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
*
* Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
* @param property_name The name of the property to get
* @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
*/
get_property(property_name: string, value: GObject.Value | any): any;
/**
* This function gets back user data pointers stored via
* g_object_set_qdata().
* @param quark A #GQuark, naming the user data pointer
* @returns The user data pointer set, or %NULL
*/
get_qdata(quark: GLib.Quark): any | null;
/**
* Gets `n_properties` properties for an `object`.
* Obtained properties will be set to `values`. All properties must be valid.
* Warnings will be emitted and undefined behaviour may result if invalid
* properties are passed in.
* @param names the names of each property to get
* @param values the values of each property to get
*/
getv(names: string[], values: (GObject.Value | any)[]): void;
/**
* Checks whether `object` has a [floating][floating-ref] reference.
* @returns %TRUE if @object has a floating reference
*/
is_floating(): boolean;
/**
* Emits a "notify" signal for the property `property_name` on `object`.
*
* When possible, eg. when signaling a property change from within the class
* that registered the property, you should use g_object_notify_by_pspec()
* instead.
*
* Note that emission of the notify signal may be blocked with
* g_object_freeze_notify(). In this case, the signal emissions are queued
* and will be emitted (in reverse order) when g_object_thaw_notify() is
* called.
* @param property_name the name of a property installed on the class of @object.
*/
notify(property_name: string): void;
/**
* Emits a "notify" signal for the property specified by `pspec` on `object`.
*
* This function omits the property name lookup, hence it is faster than
* g_object_notify().
*
* One way to avoid using g_object_notify() from within the
* class that registered the properties, and using g_object_notify_by_pspec()
* instead, is to store the GParamSpec used with
* g_object_class_install_property() inside a static array, e.g.:
*
*
* ```c
* typedef enum
* {
* PROP_FOO = 1,
* PROP_LAST
* } MyObjectProperty;
*
* static GParamSpec *properties[PROP_LAST];
*
* static void
* my_object_class_init (MyObjectClass *klass)
* {
* properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
* 0, 100,
* 50,
* G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
* g_object_class_install_property (gobject_class,
* PROP_FOO,
* properties[PROP_FOO]);
* }
* ```
*
*
* and then notify a change on the "foo" property with:
*
*
* ```c
* g_object_notify_by_pspec (self, properties[PROP_FOO]);
* ```
*
* @param pspec the #GParamSpec of a property installed on the class of @object.
*/
notify_by_pspec(pspec: GObject.ParamSpec): void;
/**
* Increases the reference count of `object`.
*
* Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
* of `object` will be propagated to the return type (using the GCC typeof()
* extension), so any casting the caller needs to do on the return type must be
* explicit.
* @returns the same @object
*/
ref(): GObject.Object;
/**
* Increase the reference count of `object,` and possibly remove the
* [floating][floating-ref] reference, if `object` has a floating reference.
*
* In other words, if the object is floating, then this call "assumes
* ownership" of the floating reference, converting it to a normal
* reference by clearing the floating flag while leaving the reference
* count unchanged. If the object is not floating, then this call
* adds a new normal reference increasing the reference count by one.
*
* Since GLib 2.56, the type of `object` will be propagated to the return type
* under the same conditions as for g_object_ref().
* @returns @object
*/
ref_sink(): GObject.Object;
/**
* Releases all references to other objects. This can be used to break
* reference cycles.
*
* This function should only be called from object system implementations.
*/
run_dispose(): void;
/**
* Each object carries around a table of associations from
* strings to pointers. This function lets you set an association.
*
* If the object already had an association with that name,
* the old association will be destroyed.
*
* Internally, the `key` is converted to a #GQuark using g_quark_from_string().
* This means a copy of `key` is kept permanently (even after `object` has been
* finalized) — so it is recommended to only use a small, bounded set of values
* for `key` in your program, to avoid the #GQuark storage growing unbounded.
* @param key name of the key
* @param data data to associate with that key
*/
set_data(key: string, data?: any | null): void;
/**
* Sets a property on an object.
* @param property_name The name of the property to set
* @param value The value to set the property to
*/
set_property(property_name: string, value: GObject.Value | any): void;
/**
* Remove a specified datum from the object's data associations,
* without invoking the association's destroy handler.
* @param key name of the key
* @returns the data if found, or %NULL if no such data exists.
*/
steal_data(key: string): any | null;
/**
* This function gets back user data pointers stored via
* g_object_set_qdata() and removes the `data` from object
* without invoking its destroy() function (if any was
* set).
* Usually, calling this function is only required to update
* user data pointers with a destroy notifier, for example:
*
* ```c
* void
* object_add_to_user_list (GObject *object,
* const gchar *new_string)
* {
* // the quark, naming the object data
* GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
* // retrieve the old string list
* GList *list = g_object_steal_qdata (object, quark_string_list);
*
* // prepend new string
* list = g_list_prepend (list, g_strdup (new_string));
* // this changed 'list', so we need to set it again
* g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
* }
* static void
* free_string_list (gpointer data)
* {
* GList *node, *list = data;
*
* for (node = list; node; node = node->next)
* g_free (node->data);
* g_list_free (list);
* }
* ```
*
* Using g_object_get_qdata() in the above example, instead of
* g_object_steal_qdata() would have left the destroy function set,
* and thus the partial string list would have been freed upon
* g_object_set_qdata_full().
* @param quark A #GQuark, naming the user data pointer
* @returns The user data pointer set, or %NULL
*/
steal_qdata(quark: GLib.Quark): any | null;
/**
* Reverts the effect of a previous call to
* g_object_freeze_notify(). The freeze count is decreased on `object`
* and when it reaches zero, queued "notify" signals are emitted.
*
* Duplicate notifications for each property are squashed so that at most one
* #GObject::notify signal is emitted for each property, in the reverse order
* in which they have been queued.
*
* It is an error to call this function when the freeze count is zero.
*/
thaw_notify(): void;
/**
* Decreases the reference count of `object`. When its reference count
* drops to 0, the object is finalized (i.e. its memory is freed).
*
* If the pointer to the #GObject may be reused in future (for example, if it is
* an instance variable of another object), it is recommended to clear the
* pointer to %NULL rather than retain a dangling pointer to a potentially
* invalid #GObject instance. Use g_clear_object() for this.
*/
unref(): void;
/**
* This function essentially limits the life time of the `closure` to
* the life time of the object. That is, when the object is finalized,
* the `closure` is invalidated by calling g_closure_invalidate() on
* it, in order to prevent invocations of the closure with a finalized
* (nonexisting) object. Also, g_object_ref() and g_object_unref() are
* added as marshal guards to the `closure,` to ensure that an extra
* reference count is held on `object` during invocation of the
* `closure`. Usually, this function will be called on closures that
* use this `object` as closure data.
* @param closure #GClosure to watch
*/
watch_closure(closure: GObject.Closure): void;
/**
* the `constructed` function is called by g_object_new() as the
* final step of the object creation process. At the point of the call, all
* construction properties have been set on the object. The purpose of this
* call is to allow for object initialisation steps that can only be performed
* after construction properties have been set. `constructed` implementors
* should chain up to the `constructed` call of their parent class to allow it
* to complete its initialisation.
*/
vfunc_constructed(): void;
/**
* emits property change notification for a bunch
* of properties. Overriding `dispatch_properties_changed` should be rarely
* needed.
* @param n_pspecs
* @param pspecs
*/
vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
/**
* the `dispose` function is supposed to drop all references to other
* objects, but keep the instance otherwise intact, so that client method
* invocations still work. It may be run multiple times (due to reference
* loops). Before returning, `dispose` should chain up to the `dispose` method
* of the parent class.
*/
vfunc_dispose(): void;
/**
* instance finalization function, should finish the finalization of
* the instance begun in `dispose` and chain up to the `finalize` method of the
* parent class.
*/
vfunc_finalize(): void;
/**
* the generic getter for all properties of this type. Should be
* overridden for every type with properties.
* @param property_id
* @param value
* @param pspec
*/
vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
/**
* Emits a "notify" signal for the property `property_name` on `object`.
*
* When possible, eg. when signaling a property change from within the class
* that registered the property, you should use g_object_notify_by_pspec()
* instead.
*
* Note that emission of the notify signal may be blocked with
* g_object_freeze_notify(). In this case, the signal emissions are queued
* and will be emitted (in reverse order) when g_object_thaw_notify() is
* called.
* @param pspec
*/
vfunc_notify(pspec: GObject.ParamSpec): void;
/**
* the generic setter for all properties of this type. Should be
* overridden for every type with properties. If implementations of
* `set_property` don't emit property change notification explicitly, this will
* be done implicitly by the type system. However, if the notify signal is
* emitted explicitly, the type system will not emit it a second time.
* @param property_id
* @param value
* @param pspec
*/
vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
/**
* Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
* @param id Handler ID of the handler to be disconnected
*/
disconnect(id: number): void;
/**
* Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
* @param properties Object containing the properties to set
*/
set(properties: { [key: string]: any }): void;
/**
* Blocks a handler of an instance so it will not be called during any signal emissions
* @param id Handler ID of the handler to be blocked
*/
block_signal_handler(id: number): void;
/**
* Unblocks a handler so it will be called again during any signal emissions
* @param id Handler ID of the handler to be unblocked
*/
unblock_signal_handler(id: number): void;
/**
* Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
* @param detailedName Name of the signal to stop emission of
*/
stop_emission_by_name(detailedName: string): void;
}
namespace Device {
// Signal callback interfaces
interface StateChanged {
(new_state: number, old_state: number, reason: number): void;
}
// Constructor properties interface
interface ConstructorProps extends Object.ConstructorProps {
active_connection: ActiveConnection;
activeConnection: ActiveConnection;
autoconnect: boolean;
available_connections: RemoteConnection[];
availableConnections: RemoteConnection[];
capabilities: DeviceCapabilities;
device_type: DeviceType;
deviceType: DeviceType;
dhcp4_config: DhcpConfig;
dhcp4Config: DhcpConfig;
dhcp6_config: DhcpConfig;
dhcp6Config: DhcpConfig;
driver: string;
driver_version: string;
driverVersion: string;
firmware_missing: boolean;
firmwareMissing: boolean;
firmware_version: string;
firmwareVersion: string;
hw_address: string;
hwAddress: string;
interface: string;
interface_flags: number;
interfaceFlags: number;
ip_interface: string;
ipInterface: string;
ip4_config: IPConfig;
ip4Config: IPConfig;
ip4_connectivity: ConnectivityState;
ip4Connectivity: ConnectivityState;
ip6_config: IPConfig;
ip6Config: IPConfig;
ip6_connectivity: ConnectivityState;
ip6Connectivity: ConnectivityState;
lldp_neighbors: any[];
lldpNeighbors: any[];
managed: boolean;
metered: number;
mtu: number;
nm_plugin_missing: boolean;
nmPluginMissing: boolean;
path: string;
physical_port_id: string;
physicalPortId: string;
ports: any[];
product: string;
real: boolean;
state: DeviceState;
state_reason: number;
stateReason: number;
udi: string;
vendor: string;
}
}
abstract class Device extends Object {
static $gtype: GObject.GType;
// Properties
/**
* The #NMActiveConnection object that "owns" this device during activation.
*/
get active_connection(): ActiveConnection;
/**
* The #NMActiveConnection object that "owns" this device during activation.
*/
get activeConnection(): ActiveConnection;
/**
* Whether the device can auto-activate a connection.
*
* The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
*/
get autoconnect(): boolean;
set autoconnect(val: boolean);
/**
* The available connections of the device
*/
get available_connections(): RemoteConnection[];
/**
* The available connections of the device
*/
get availableConnections(): RemoteConnection[];
/**
* The capabilities of the device.
*/
get capabilities(): DeviceCapabilities;
/**
* The numeric type of the device.
*/
get device_type(): DeviceType;
/**
* The numeric type of the device.
*/
get deviceType(): DeviceType;
/**
* The IPv4 #NMDhcpConfig of the device.
*/
get dhcp4_config(): DhcpConfig;
/**
* The IPv4 #NMDhcpConfig of the device.
*/
get dhcp4Config(): DhcpConfig;
/**
* The IPv6 #NMDhcpConfig of the device.
*/
get dhcp6_config(): DhcpConfig;
/**
* The IPv6 #NMDhcpConfig of the device.
*/
get dhcp6Config(): DhcpConfig;
/**
* The driver of the device.
*/
get driver(): string;
/**
* The version of the device driver.
*/
get driver_version(): string;
/**
* The version of the device driver.
*/
get driverVersion(): string;
/**
* When %TRUE indicates the device is likely missing firmware required
* for its operation.
*/
get firmware_missing(): boolean;
/**
* When %TRUE indicates the device is likely missing firmware required
* for its operation.
*/
get firmwareMissing(): boolean;
/**
* The firmware version of the device.
*/
get firmware_version(): string;
/**
* The firmware version of the device.
*/
get firmwareVersion(): string;
/**
* The hardware address of the device.
*/
get hw_address(): string;
/**
* The hardware address of the device.
*/
get hwAddress(): string;
/**
* The interface of the device.
*/
get interface(): string;
/**
* The interface flags.
*/
get interface_flags(): number;
/**
* The interface flags.
*/
get interfaceFlags(): number;
/**
* The IP interface of the device which should be used for all IP-related
* operations like addressing and routing.
*/
get ip_interface(): string;
/**
* The IP interface of the device which should be used for all IP-related
* operations like addressing and routing.
*/
get ipInterface(): string;
/**
* The #NMIP4Config of the device.
*/
get ip4_config(): IPConfig;
/**
* The #NMIP4Config of the device.
*/
get ip4Config(): IPConfig;
/**
* The IPv4 connectivity state of the device.
*/
get ip4_connectivity(): ConnectivityState;
/**
* The IPv4 connectivity state of the device.
*/
get ip4Connectivity(): ConnectivityState;
/**
* The IPv6 #NMIPConfig of the device.
*/
get ip6_config(): IPConfig;
/**
* The IPv6 #NMIPConfig of the device.
*/
get ip6Config(): IPConfig;
/**
* The IPv6 connectivity state of the device.
*/
get ip6_connectivity(): ConnectivityState;
/**
* The IPv6 connectivity state of the device.
*/
get ip6Connectivity(): ConnectivityState;
/**
* The LLDP neighbors.
*/
get lldp_neighbors(): any[];
/**
* The LLDP neighbors.
*/
get lldpNeighbors(): any[];
/**
* Whether the device is managed by NetworkManager.
*/
get managed(): boolean;
/**
* Whether the device is metered.
*/
get metered(): number;
/**
* The MTU of the device.
*/
get mtu(): number;
/**
* When %TRUE indicates that the NetworkManager plugin for the device
* is not installed.
*/
get nm_plugin_missing(): boolean;
/**
* When %TRUE indicates that the NetworkManager plugin for the device
* is not installed.
*/
get nmPluginMissing(): boolean;
/**
* The device path as exposed by the udev property ID_PATH.
*
* The string is backslash escaped (C escaping) for invalid
* characters. The escaping can be reverted with g_strcompress(),
* however the result may not be valid UTF-8.
*/
get path(): string;
/**
* The physical port ID of the device. (See
* nm_device_get_physical_port_id().)
*/
get physical_port_id(): string;
/**
* The physical port ID of the device. (See
* nm_device_get_physical_port_id().)
*/
get physicalPortId(): string;
/**
* The port devices of the controller device. For devices that cannot be
* controllers this is likely to be always empty.
*/
get ports(): any[];
/**
* The product string of the device.
*/
get product(): string;
/**
* Whether the device is real or is a placeholder device that could
* be created automatically by NetworkManager if one of its
* #NMDevice:available-connections was activated.
*/
get real(): boolean;
/**
* The state of the device.
*/
get state(): DeviceState;
/**
* The reason for the device state.
*/
get state_reason(): number;
/**
* The reason for the device state.
*/
get stateReason(): number;
/**
* An operating-system specific device hardware identifier; this is not
* unique to a specific hardware device across reboots or hotplugs. It
* is an opaque string which for some device types (Bluetooth, Modem)
* contains an identifier provided by the underlying hardware service daemon
* such as Bluez or ModemManager, and clients can use this property to
* request more information about the device from those services.
*/
get udi(): string;
/**
* The vendor string of the device.
*/
get vendor(): string;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Signals
connect(id: string, callback: (...args: any[]) => any): number;
connect_after(id: string, callback: (...args: any[]) => any): number;
emit(id: string, ...args: any[]): void;
connect(
signal: 'state-changed',
callback: (_source: this, new_state: number, old_state: number, reason: number) => void,
): number;
connect_after(
signal: 'state-changed',
callback: (_source: this, new_state: number, old_state: number, reason: number) => void,
): number;
emit(signal: 'state-changed', new_state: number, old_state: number, reason: number): void;
// Static methods
/**
* Generates a list of short-ish unique presentation names for the
* devices in `devices`.
* @param devices an array of #NMDevice
*/
static disambiguate_names(devices: Device[]): string[];
// Methods
/**
* Validates a given connection for a given #NMDevice object and returns
* whether the connection may be activated with the device. For example if
* `device` is a Wi-Fi device that supports only WEP encryption, the connection
* will only be valid if it is a Wi-Fi connection which describes a WEP or open
* network, and will not be valid if it describes a WPA network, or if it is
* an Ethernet, Bluetooth, WWAN, etc connection that is incompatible with the
* device.
*
* This function does the same as nm_device_connection_valid(), i.e. checking
* compatibility of the given device and connection. But, in addition, it sets
* GError when FALSE is returned.
* @param connection an #NMConnection to validate against @device
* @returns %TRUE if the connection may be activated with this device, %FALSE if is incompatible with the device's capabilities and characteristics.
*/
connection_compatible(connection: Connection): boolean;
/**
* Validates a given connection for a given #NMDevice object and returns
* whether the connection may be activated with the device. For example if
* `device` is a Wi-Fi device that supports only WEP encryption, the connection
* will only be valid if it is a Wi-Fi connection which describes a WEP or open
* network, and will not be valid if it describes a WPA network, or if it is
* an Ethernet, Bluetooth, WWAN, etc connection that is incompatible with the
* device.
* @param connection an #NMConnection to validate against @device
* @returns %TRUE if the connection may be activated with this device, %FALSE if is incompatible with the device's capabilities and characteristics.
*/
connection_valid(connection: Connection): boolean;
/**
* Deletes the software device. Hardware devices can't be deleted.
* @param cancellable a #GCancellable, or %NULL
* @returns %TRUE on success, %FALSE on error, in which case @error will be set.
*/
['delete'](cancellable?: Gio.Cancellable | null): boolean;
/**
* Asynchronously begins deleting the software device. Hardware devices can't
* be deleted.
* @param cancellable a #GCancellable, or %NULL
*/
delete_async(cancellable?: Gio.Cancellable | null): Promise;
/**
* Asynchronously begins deleting the software device. Hardware devices can't
* be deleted.
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when delete operation completes
*/
delete_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback | null): void;
/**
* Asynchronously begins deleting the software device. Hardware devices can't
* be deleted.
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when delete operation completes
*/
delete_async(
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise | void;
/**
* Gets the result of a call to nm_device_delete_async().
* @param result the result passed to the #GAsyncReadyCallback
* @returns %TRUE on success, %FALSE on error, in which case @error will be set.
*/
delete_finish(result: Gio.AsyncResult): boolean;
/**
* Disconnects the device if currently connected, and prevents the device from
* automatically connecting to networks until the next manual network connection
* request.
* @param cancellable a #GCancellable, or %NULL
* @returns %TRUE on success, %FALSE on error, in which case @error will be set.
*/
disconnect(cancellable?: Gio.Cancellable | null): boolean;
// Conflicted with GObject.Object.disconnect
disconnect(...args: never[]): any;
/**
* Asynchronously begins disconnecting the device if currently connected, and
* prevents the device from automatically connecting to networks until the next
* manual network connection request.
* @param cancellable a #GCancellable, or %NULL
*/
disconnect_async(cancellable?: Gio.Cancellable | null): Promise;
/**
* Asynchronously begins disconnecting the device if currently connected, and
* prevents the device from automatically connecting to networks until the next
* manual network connection request.
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the disconnect operation completes
*/
disconnect_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback | null): void;
/**
* Asynchronously begins disconnecting the device if currently connected, and
* prevents the device from automatically connecting to networks until the next
* manual network connection request.
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the disconnect operation completes
*/
disconnect_async(
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise | void;
/**
* Gets the result of a call to nm_device_disconnect_async().
* @param result the result passed to the #GAsyncReadyCallback
* @returns %TRUE on success, %FALSE on error, in which case @error will be set.
*/
disconnect_finish(result: Gio.AsyncResult): boolean;
/**
* Filters a given array of connections for a given #NMDevice object and returns
* connections which may be activated with the device. For example if `device`
* is a Wi-Fi device that supports only WEP encryption, the returned array will
* contain any Wi-Fi connections in `connections` that allow connection to
* unencrypted or WEP-enabled SSIDs. The returned array will not contain
* Ethernet, Bluetooth, Wi-Fi WPA connections, or any other connection that is
* incompatible with the device. To get the full list of connections see
* nm_client_get_connections().
* @param connections an array of #NMConnections to filter
* @returns an array of #NMConnections that could be activated with the given @device. The array should be freed with g_ptr_array_unref() when it is no longer required. WARNING: the transfer annotation for this function may not work correctly with bindings. See https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/305. You can filter the list yourself with nm_device_connection_valid().
*/
filter_connections(connections: Connection[]): Connection[];
/**
* Gets the #NMActiveConnection object which owns this device during activation.
* @returns the #NMActiveConnection or %NULL if the device is not part of an active connection
*/
get_active_connection(): ActiveConnection;
/**
* Fetch the currently applied connection on the device.
* @param flags the flags argument. See #NMDeviceReapplyFlags.
* @param cancellable a #GCancellable, or %NULL
* @returns a %NMConnection with the currently applied settings or %NULL on error. The connection is as received from D-Bus and might not validate according to nm_connection_verify().
*/
get_applied_connection(flags: number, cancellable?: Gio.Cancellable | null): [Connection, number];
/**
* Asynchronously begins and gets the currently applied connection.
* @param flags the flags argument. See #NMDeviceReapplyFlags.
* @param cancellable a #GCancellable, or %NULL
*/
get_applied_connection_async(
flags: number,
cancellable?: Gio.Cancellable | null,
): Promise<[Connection, number]>;
/**
* Asynchronously begins and gets the currently applied connection.
* @param flags the flags argument. See #NMDeviceReapplyFlags.
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the reapply operation completes
*/
get_applied_connection_async(
flags: number,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback | null,
): void;
/**
* Asynchronously begins and gets the currently applied connection.
* @param flags the flags argument. See #NMDeviceReapplyFlags.
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the reapply operation completes
*/
get_applied_connection_async(
flags: number,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise<[Connection, number]> | void;
/**
* Gets the result of a call to nm_device_get_applied_connection_async().
* @param result the result passed to the #GAsyncReadyCallback
* @returns a currently applied %NMConnection or %NULL in case of error. The connection is as received from D-Bus and might not validate according to nm_connection_verify().
*/
get_applied_connection_finish(result: Gio.AsyncResult): [Connection, number];
/**
* Whether the #NMDevice can be autoconnected.
* @returns %TRUE if the device is allowed to be autoconnected
*/
get_autoconnect(): boolean;
/**
* Gets the #NMRemoteConnections currently known to the daemon that could
* be activated on `device`.
* @returns the #GPtrArray containing #NMRemoteConnections. This is the internal copy used by the connection, and must not be modified.
*/
get_available_connections(): RemoteConnection[];
/**
* Gets the device' capabilities.
* @returns the capabilities
*/
get_capabilities(): DeviceCapabilities;
/**
* The connectivity state of the device for given address family.
* Supported address families are %AF_INET for IPv4, %AF_INET6
* for IPv6 or %AF_UNSPEC for any.
* @param addr_family network address family
* @returns the current connectivity state
*/
get_connectivity(addr_family: number): ConnectivityState;
/**
* Gets a description of `device,` based on its vendor and product names.
* @returns a description of @device. If either the vendor or the product name is unknown, this returns the interface name.
*/
get_description(): string;
/**
* Returns the numeric type of the #NMDevice, ie Ethernet, Wi-Fi, etc.
* @returns the device type
*/
get_device_type(): DeviceType;
/**
* Gets the current IPv4 #NMDhcpConfig associated with the #NMDevice.
*
* You can alternatively use nm_active_connection_get_dhcp4_config(), which also
* works with VPN connections.
* @returns the IPv4 #NMDhcpConfig, or %NULL if the device is not activated or not using DHCP.
*/
get_dhcp4_config(): DhcpConfig;
/**
* Gets the current IPv6 #NMDhcpConfig associated with the #NMDevice.
*
* You can alternatively use nm_active_connection_get_dhcp6_config(), which also
* works with VPN connections.
* @returns the IPv6 #NMDhcpConfig, or %NULL if the device is not activated or not using DHCPv6.
*/
get_dhcp6_config(): DhcpConfig;
/**
* Gets the driver of the #NMDevice.
* @returns the driver of the device. This is the internal string used by the device, and must not be modified.
*/
get_driver(): string;
/**
* Gets the driver version of the #NMDevice.
* @returns the version of the device driver. This is the internal string used by the device, and must not be modified.
*/
get_driver_version(): string;
/**
* Indicates that firmware required for the device's operation is likely
* to be missing.
* @returns %TRUE if firmware required for the device's operation is likely to be missing.
*/
get_firmware_missing(): boolean;
/**
* Gets the firmware version of the #NMDevice.
* @returns the firmware version of the device. This is the internal string used by the device, and must not be modified.
*/
get_firmware_version(): string;
/**
* Gets the current a hardware address (MAC) for the `device`.
* @returns the current MAC of the device, or %NULL. This is the internal string used by the device, and must not be modified.
*/
get_hw_address(): string;
/**
* Gets the interface name of the #NMDevice.
* @returns the interface of the device. This is the internal string used by the device, and must not be modified.
*/
get_iface(): string;
/**
* Gets the interface flags of the device.
* @returns the flags
*/
get_interface_flags(): DeviceInterfaceFlags;
/**
* Gets the current IPv4 #NMIPConfig associated with the #NMDevice.
*
* You can alternatively use nm_active_connection_get_ip4_config(), which also
* works with VPN connections.
* @returns the IPv4 #NMIPConfig, or %NULL if the device is not activated.
*/
get_ip4_config(): IPConfig;
/**
* Gets the current IPv6 #NMIPConfig associated with the #NMDevice.
*
* You can alternatively use nm_active_connection_get_ip6_config(), which also
* works with VPN connections.
* @returns the IPv6 #NMIPConfig or %NULL if the device is not activated.
*/
get_ip6_config(): IPConfig;
/**
* Gets the IP interface name of the #NMDevice over which IP traffic flows
* when the device is in the ACTIVATED state.
* @returns the IP traffic interface of the device. This is the internal string used by the device, and must not be modified.
*/
get_ip_iface(): string;
/**
* Gets the list of neighbors discovered through LLDP.
* @returns the #GPtrArray containing #NMLldpNeighbors. This is the internal copy used by the device and must not be modified. The library never modifies the returned array and thus it is safe for callers to reference and keep using it.
*/
get_lldp_neighbors(): LldpNeighbor[];
/**
* Whether the #NMDevice is managed by NetworkManager.
* @returns %TRUE if the device is managed by NetworkManager
*/
get_managed(): boolean;
/**
* Gets the metered setting of a #NMDevice.
* @returns the metered setting.
*/
get_metered(): Metered;
/**
* Gets the MTU of the #NMDevice.
* @returns the MTU of the device in bytes.
*/
get_mtu(): number;
/**
* Indicates that the NetworkManager plugin for the device is not installed.
* @returns %TRUE if the device plugin not installed.
*/
get_nm_plugin_missing(): boolean;
/**
* Gets the path of the #NMDevice as exposed by the udev property ID_PATH.
* @returns the path of the device. The string is backslash escaped (C escaping) for invalid characters. The escaping can be reverted with g_strcompress(), however the result may not be valid UTF-8.
*/
get_path(): string;
/**
* Gets the physical port ID of the #NMDevice. If non-%NULL, this is
* an opaque string that can be used to recognize when
* seemingly-unrelated #NMDevices are actually just different virtual
* ports on a single physical port. (Eg, NPAR / SR-IOV.)
* @returns the physical port ID of the device, or %NULL if the port ID is unknown. This is the internal string used by the device and must not be modified.
*/
get_physical_port_id(): string;
/**
* Gets the devices currently set as port of `device`.
* @returns the #GPtrArray containing #NMDevices that are ports of @device. This is the internal copy used by the device and must not be modified.
*/
get_ports(): Device[];
/**
* Gets the product string of the #NMDevice.
* @returns the product name of the device. This is the internal string used by the device, and must not be modified. The string is backslash escaped (C escaping) for invalid characters. The escaping can be reverted with g_strcompress(), however the result may not be valid UTF-8.
*/
get_product(): string;
/**
* Gets the (primary) #NMSetting subtype associated with connections
* that can be used on `device`.
* @returns @device's associated #NMSetting type
*/
get_setting_type(): GObject.GType;
/**
* Gets the current #NMDevice state.
* @returns the current device state
*/
get_state(): DeviceState;
/**
* Gets the reason for entering the current #NMDevice state.
* @returns the reason for entering the current device state
*/
get_state_reason(): DeviceStateReason;
/**
* Gets a (non-localized) description of the type of device that
* `device` is.
* @returns the type description of the device. This is the internal string used by the device, and must not be modified.
*/
get_type_description(): string;
/**
* Gets the Unique Device Identifier of the #NMDevice.
* @returns the Unique Device Identifier of the device. This identifier may be used to gather more information about the device from various operating system services like udev or sysfs.
*/
get_udi(): string;
/**
* Gets the vendor string of the #NMDevice.
* @returns the vendor name of the device. This is the internal string used by the device, and must not be modified. The string is backslash escaped (C escaping) for invalid characters. The escaping can be reverted with g_strcompress(), however the result may not be valid UTF-8.
*/
get_vendor(): string;
is_real(): boolean;
/**
* Whether the device is a software device.
* @returns %TRUE if @device is a software device, %FALSE if it is a hardware device.
*/
is_software(): boolean;
/**
* Attempts to update device with changes to the currently active connection
* made since it was last applied.
* @param connection the #NMConnection to replace the applied settings with or %NULL to reuse existing
* @param version_id zero or the expected version id of the applied connection. If specified and the version id mismatches, the call fails without modification. This allows to catch concurrent accesses.
* @param flags always set this to zero
* @param cancellable a #GCancellable, or %NULL
* @returns %TRUE on success, %FALSE on error, in which case @error will be set.
*/
reapply(
connection: Connection | null,
version_id: number,
flags: number,
cancellable?: Gio.Cancellable | null,
): boolean;
/**
* Asynchronously begins an attempt to update device with changes to the
* currently active connection made since it was last applied.
* @param connection the #NMConnection to replace the applied settings with or %NULL to reuse existing
* @param version_id zero or the expected version id of the applied connection. If specified and the version id mismatches, the call fails without modification. This allows to catch concurrent accesses.
* @param flags always set this to zero
* @param cancellable a #GCancellable, or %NULL
*/
reapply_async(
connection: Connection | null,
version_id: number,
flags: number,
cancellable?: Gio.Cancellable | null,
): Promise;
/**
* Asynchronously begins an attempt to update device with changes to the
* currently active connection made since it was last applied.
* @param connection the #NMConnection to replace the applied settings with or %NULL to reuse existing
* @param version_id zero or the expected version id of the applied connection. If specified and the version id mismatches, the call fails without modification. This allows to catch concurrent accesses.
* @param flags always set this to zero
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the reapply operation completes
*/
reapply_async(
connection: Connection | null,
version_id: number,
flags: number,
cancellable: Gio.Cancellable | null,
callback: Gio.AsyncReadyCallback | null,
): void;
/**
* Asynchronously begins an attempt to update device with changes to the
* currently active connection made since it was last applied.
* @param connection the #NMConnection to replace the applied settings with or %NULL to reuse existing
* @param version_id zero or the expected version id of the applied connection. If specified and the version id mismatches, the call fails without modification. This allows to catch concurrent accesses.
* @param flags always set this to zero
* @param cancellable a #GCancellable, or %NULL
* @param callback callback to be called when the reapply operation completes
*/
reapply_async(
connection: Connection | null,
version_id: number,
flags: number,
cancellable?: Gio.Cancellable | null,
callback?: Gio.AsyncReadyCallback | null,
): Promise | void;
/**
* Gets the result of a call to nm_device_reapply_async().
* @param result the result passed to the #GAsyncReadyCallback
* @returns %TRUE on success, %FALSE on error, in which case @error will be set.
*/
reapply_finish(result: Gio.AsyncResult): boolean;
/**
* Enables or disables automatic activation of the #NMDevice.
* @param autoconnect %TRUE to enable autoconnecting
*/
set_autoconnect(autoconnect: boolean): void;
/**
* Enables or disables management of #NMDevice by NetworkManager.
* @param managed %TRUE to make the device managed by NetworkManager.
*/
set_managed(managed: boolean): void;
}
namespace Device6Lowpan {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
parent: Device;
}
}
class Device6Lowpan extends Device {
static $gtype: GObject.GType;
// Properties
/**
* The devices's parent device.
*/
get parent(): Device;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
get_parent(): Device;
}
namespace DeviceAdsl {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
carrier: boolean;
}
}
class DeviceAdsl extends Device {
static $gtype: GObject.GType;
// Properties
/**
* Whether the device has carrier.
*/
get carrier(): boolean;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
/**
* Whether the device has carrier.
* @returns %TRUE if the device has carrier
*/
get_carrier(): boolean;
}
namespace DeviceBond {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
carrier: boolean;
slaves: Device[];
}
}
class DeviceBond extends Device {
static $gtype: GObject.GType;
// Properties
/**
* Whether the device has carrier.
*/
get carrier(): boolean;
/**
* The devices attached as port to the bond device.
*/
get slaves(): Device[];
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
/**
* Whether the device has carrier.
* @returns %TRUE if the device has carrier
*/
get_carrier(): boolean;
/**
* Gets the devices currently attached as port to `device`.
* @returns the #GPtrArray containing #NMDevices that are slaves of @device. This is the internal copy used by the device, and must not be modified.
*/
get_slaves(): Device[];
}
namespace DeviceBridge {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
carrier: boolean;
slaves: Device[];
}
}
class DeviceBridge extends Device {
static $gtype: GObject.GType;
// Properties
/**
* Whether the device has carrier.
*/
get carrier(): boolean;
/**
* The devices attached as port to the bridge device.
*/
get slaves(): Device[];
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
/**
* Whether the device has carrier.
* @returns %TRUE if the device has carrier
*/
get_carrier(): boolean;
/**
* Gets the devices currently attached as port to `device`.
* @returns the #GPtrArray containing #NMDevices that are ports of @device. This is the internal copy used by the device, and must not be modified.
*/
get_slaves(): Device[];
}
namespace DeviceBt {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
bt_capabilities: BluetoothCapabilities;
btCapabilities: BluetoothCapabilities;
name: string;
}
}
class DeviceBt extends Device {
static $gtype: GObject.GType;
// Properties
/**
* The device's bluetooth capabilities, a combination of #NMBluetoothCapabilities.
*/
get bt_capabilities(): BluetoothCapabilities;
/**
* The device's bluetooth capabilities, a combination of #NMBluetoothCapabilities.
*/
get btCapabilities(): BluetoothCapabilities;
/**
* The name of the bluetooth device.
*/
get name(): string;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
/**
* Returns the Bluetooth device's usable capabilities.
* @returns a combination of #NMBluetoothCapabilities
*/
get_capabilities(): BluetoothCapabilities;
// Conflicted with NM.Device.get_capabilities
get_capabilities(...args: never[]): any;
/**
* Gets the name of the #NMDeviceBt.
* @returns the name of the device
*/
get_name(): string;
}
namespace DeviceDummy {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {}
}
class DeviceDummy extends Device {
static $gtype: GObject.GType;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
}
namespace DeviceEthernet {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
carrier: boolean;
perm_hw_address: string;
permHwAddress: string;
s390_subchannels: string[];
s390Subchannels: string[];
speed: number;
}
}
class DeviceEthernet extends Device {
static $gtype: GObject.GType;
// Properties
/**
* Whether the device has carrier.
*/
get carrier(): boolean;
/**
* The permanent hardware (MAC) address of the device.
*/
get perm_hw_address(): string;
/**
* The permanent hardware (MAC) address of the device.
*/
get permHwAddress(): string;
/**
* Identifies subchannels of this network device used for
* communication with z/VM or s390 host.
*/
get s390_subchannels(): string[];
/**
* Identifies subchannels of this network device used for
* communication with z/VM or s390 host.
*/
get s390Subchannels(): string[];
/**
* The speed of the device.
*/
get speed(): number;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
/**
* Whether the device has carrier.
* @returns %TRUE if the device has carrier
*/
get_carrier(): boolean;
/**
* Gets the permanent hardware (MAC) address of the #NMDeviceEthernet
* @returns the permanent hardware address. This is the internal string used by the device, and must not be modified.
*/
get_permanent_hw_address(): string;
/**
* Return the list of s390 subchannels if the device supports them.
* @returns array of strings, each specifying one subchannel the s390 device uses to communicate to the host.
*/
get_s390_subchannels(): string[];
/**
* Gets the speed of the #NMDeviceEthernet in Mbit/s.
* @returns the speed of the device in Mbit/s
*/
get_speed(): number;
}
namespace DeviceGeneric {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
type_description: string;
typeDescription: string;
}
}
class DeviceGeneric extends Device {
static $gtype: GObject.GType;
// Properties
/**
* A description of the specific type of device this is, or %NULL
* if not known.
*/
get type_description(): string;
/**
* A description of the specific type of device this is, or %NULL
* if not known.
*/
get typeDescription(): string;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
}
namespace DeviceHsr {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
multicast_spec: number;
multicastSpec: number;
port1: Device;
port2: Device;
prp: boolean;
supervision_address: string;
supervisionAddress: string;
}
}
class DeviceHsr extends Device {
static $gtype: GObject.GType;
// Properties
/**
* The device last byte of the supervision address.
*/
get multicast_spec(): number;
/**
* The device last byte of the supervision address.
*/
get multicastSpec(): number;
/**
* The device's port1 device.
*/
get port1(): Device;
/**
* The device's port2 device.
*/
get port2(): Device;
/**
* Whether the PRP protocol is used or not.
*/
get prp(): boolean;
/**
* The device supervision MAC adddress.
*/
get supervision_address(): string;
/**
* The device supervision MAC adddress.
*/
get supervisionAddress(): string;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
get_multicast_spec(): number;
get_port1(): Device;
get_port2(): Device;
get_prp(): boolean;
get_supervision_address(): string;
}
namespace DeviceIPTunnel {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
encapsulation_limit: number;
encapsulationLimit: number;
flags: number;
flow_label: number;
flowLabel: number;
fwmark: number;
input_key: string;
inputKey: string;
local: string;
mode: number;
output_key: string;
outputKey: string;
parent: Device;
path_mtu_discovery: boolean;
pathMtuDiscovery: boolean;
remote: string;
tos: number;
ttl: number;
}
}
class DeviceIPTunnel extends Device {
static $gtype: GObject.GType;
// Properties
/**
* How many additional levels of encapsulation are permitted to
* be prepended to packets. This property applies only to IPv6
* tunnels.
*/
get encapsulation_limit(): number;
/**
* How many additional levels of encapsulation are permitted to
* be prepended to packets. This property applies only to IPv6
* tunnels.
*/
get encapsulationLimit(): number;
/**
* Tunnel flags.
*/
get flags(): number;
/**
* The flow label to assign to tunnel packets. This property
* applies only to IPv6 tunnels.
*/
get flow_label(): number;
/**
* The flow label to assign to tunnel packets. This property
* applies only to IPv6 tunnels.
*/
get flowLabel(): number;
/**
* The fwmark value to assign to tunnel packets. This property applies only
* to VTI tunnels.
*/
get fwmark(): number;
/**
* The key used for tunneled input packets, if applicable.
*/
get input_key(): string;
/**
* The key used for tunneled input packets, if applicable.
*/
get inputKey(): string;
/**
* The local endpoint of the tunnel.
*/
get local(): string;
/**
* The tunneling mode of the device.
*/
get mode(): number;
/**
* The key used for tunneled output packets, if applicable.
*/
get output_key(): string;
/**
* The key used for tunneled output packets, if applicable.
*/
get outputKey(): string;
/**
* The devices's parent device.
*/
get parent(): Device;
/**
* Whether path MTU discovery is enabled on this tunnel.
*/
get path_mtu_discovery(): boolean;
/**
* Whether path MTU discovery is enabled on this tunnel.
*/
get pathMtuDiscovery(): boolean;
/**
* The remote endpoint of the tunnel.
*/
get remote(): string;
/**
* The type of service (IPv4) or traffic class (IPv6) assigned to
* tunneled packets.
*/
get tos(): number;
/**
* The TTL assigned to tunneled packets. 0 is a special value
* meaning that packets inherit the TTL value
*/
get ttl(): number;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
get_encapsulation_limit(): number;
get_flags(): IPTunnelFlags;
get_flow_label(): number;
get_fwmark(): number;
get_input_key(): string;
get_local(): string;
get_mode(): IPTunnelMode;
get_output_key(): string;
get_parent(): Device;
get_path_mtu_discovery(): boolean;
get_remote(): string;
get_tos(): number;
get_ttl(): number;
}
namespace DeviceInfiniband {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
carrier: boolean;
}
}
class DeviceInfiniband extends Device {
static $gtype: GObject.GType;
// Properties
/**
* Whether the device has carrier.
*/
get carrier(): boolean;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
/**
* Whether the device has carrier.
* @returns %TRUE if the device has carrier
*/
get_carrier(): boolean;
}
namespace DeviceIpvlan {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
mode: string;
parent: Device;
private: boolean;
vepa: boolean;
}
}
class DeviceIpvlan extends Device {
static $gtype: GObject.GType;
// Properties
/**
* The IPVLAN mode.
*/
get mode(): string;
/**
* The devices's parent device.
*/
get parent(): Device;
/**
* Whether the device has the private flag.
*/
get private(): boolean;
/**
* Whether the device has the VEPA flag.
*/
get vepa(): boolean;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
/**
* Gets the IPVLAN mode of the device.
* @returns the IPVLAN mode. This is the internal string used by the device, and must not be modified.
*/
get_mode(): string;
get_parent(): Device;
/**
* Gets the private flag of the device.
* @returns the private flag of the device.
*/
get_private(): boolean;
/**
* Gets the VEPA flag of the device.
* @returns the VEPA flag of the device.
*/
get_vepa(): boolean;
}
namespace DeviceLoopback {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {}
}
class DeviceLoopback extends Device {
static $gtype: GObject.GType;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
}
namespace DeviceMacsec {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
cipher_suite: number;
cipherSuite: number;
encoding_sa: number;
encodingSa: number;
encrypt: boolean;
es: boolean;
icv_length: number;
icvLength: number;
include_sci: boolean;
includeSci: boolean;
parent: Device;
protect: boolean;
replay_protect: boolean;
replayProtect: boolean;
scb: boolean;
sci: number;
validation: string;
window: number;
}
}
class DeviceMacsec extends Device {
static $gtype: GObject.GType;
// Properties
/**
* The set of cryptographic algorithms in use.
*/
get cipher_suite(): number;
/**
* The set of cryptographic algorithms in use.
*/
get cipherSuite(): number;
/**
* The value of the Association Number (0..3) for the Security
* Association in use.
*/
get encoding_sa(): number;
/**
* The value of the Association Number (0..3) for the Security
* Association in use.
*/
get encodingSa(): number;
/**
* Whether encryption of transmitted frames is enabled.
*/
get encrypt(): boolean;
/**
* Whether the ES (End station) bit is enabled in SecTAG for
* transmitted frames.
*/
get es(): boolean;
/**
* The length of ICV (Integrity Check Value).
*/
get icv_length(): number;
/**
* The length of ICV (Integrity Check Value).
*/
get icvLength(): number;
/**
* Whether the SCI is always included in SecTAG for transmitted
* frames.
*/
get include_sci(): boolean;
/**
* Whether the SCI is always included in SecTAG for transmitted
* frames.
*/
get includeSci(): boolean;
/**
* The devices's parent device.
*/
get parent(): Device;
/**
* Whether protection of transmitted frames is enabled.
*/
get protect(): boolean;
/**
* Whether replay protection is enabled.
*/
get replay_protect(): boolean;
/**
* Whether replay protection is enabled.
*/
get replayProtect(): boolean;
/**
* Whether the SCB (Single Copy Broadcast) bit is enabled in
* SecTAG for transmitted frames.
*/
get scb(): boolean;
/**
* The Secure Channel Identifier in use.
*/
get sci(): number;
/**
* The validation mode for incoming packets (strict, check,
* disabled).
*/
get validation(): string;
/**
* The size of the replay window.
*/
get window(): number;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
/**
* Gets the set of cryptographic algorithms in use
* @returns the set of cryptographic algorithms in use
*/
get_cipher_suite(): number;
/**
* Gets the value of the Association Number (0..3) for the Security
* Association in use.
* @returns the current Security Association
*/
get_encoding_sa(): number;
/**
* Gets whether encryption of transmitted frames is enabled
* @returns whether encryption is enabled
*/
get_encrypt(): boolean;
/**
* Gets whether the ES (End station) bit is enabled in SecTAG for
* transmitted frames
* @returns whether the ES (End station) bit is enabled
*/
get_es(): boolean;
/**
* Gets the length of ICV (Integrity Check Value)
* @returns the length of ICV
*/
get_icv_length(): number;
/**
* Gets whether the SCI is always included in SecTAG for transmitted
* frames
* @returns whether the SCI is always included
*/
get_include_sci(): boolean;
get_parent(): Device;
/**
* Gets whether protection of transmitted frames is enabled
* @returns whether protection is enabled
*/
get_protect(): boolean;
/**
* Gets whether replay protection is enabled
* @returns whether replay protection is enabled
*/
get_replay_protect(): boolean;
/**
* Gets whether the SCB (Single Copy Broadcast) bit is enabled in
* SecTAG for transmitted frames
* @returns whether the SCB (Single Copy Broadcast) bit is enabled
*/
get_scb(): boolean;
/**
* Gets the Secure Channel Identifier in use
* @returns the SCI
*/
get_sci(): number;
/**
* Gets the validation mode for incoming packets (strict, check,
* disabled)
* @returns the validation mode
*/
get_validation(): string;
/**
* Gets the size of the replay window
* @returns size of the replay window
*/
get_window(): number;
}
namespace DeviceMacvlan {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
mode: string;
no_promisc: boolean;
noPromisc: boolean;
parent: Device;
tap: boolean;
}
}
class DeviceMacvlan extends Device {
static $gtype: GObject.GType;
// Properties
/**
* The MACVLAN mode.
*/
get mode(): string;
/**
* Whether the device has the no-promiscuos flag.
*/
get no_promisc(): boolean;
/**
* Whether the device has the no-promiscuos flag.
*/
get noPromisc(): boolean;
/**
* The devices's parent device.
*/
get parent(): Device;
/**
* Whether the device is a MACVTAP.
*/
get tap(): boolean;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
/**
* Gets the MACVLAN mode of the device.
* @returns the MACVLAN mode. This is the internal string used by the device, and must not be modified.
*/
get_mode(): string;
/**
* Gets the no-promiscuous flag of the device.
* @returns the no-promiscuous flag of the device.
*/
get_no_promisc(): boolean;
get_parent(): Device;
/**
* Gets the device type (MACVLAN or MACVTAP).
* @returns %TRUE if the device is a MACVTAP, %FALSE if it is a MACVLAN.
*/
get_tap(): boolean;
}
namespace DeviceModem {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
apn: string;
current_capabilities: DeviceModemCapabilities;
currentCapabilities: DeviceModemCapabilities;
device_id: string;
deviceId: string;
modem_capabilities: DeviceModemCapabilities;
modemCapabilities: DeviceModemCapabilities;
operator_code: string;
operatorCode: string;
}
}
class DeviceModem extends Device {
static $gtype: GObject.GType;
// Properties
get apn(): string;
/**
* The generic family of access technologies the modem currently supports
* without a firmware reload or reinitialization.
*/
get current_capabilities(): DeviceModemCapabilities;
/**
* The generic family of access technologies the modem currently supports
* without a firmware reload or reinitialization.
*/
get currentCapabilities(): DeviceModemCapabilities;
get device_id(): string;
get deviceId(): string;
/**
* The generic family of access technologies the modem supports. Not all
* capabilities are available at the same time however; some modems require
* a firmware reload or other reinitialization to switch between eg
* CDMA/EVDO and GSM/UMTS.
*/
get modem_capabilities(): DeviceModemCapabilities;
/**
* The generic family of access technologies the modem supports. Not all
* capabilities are available at the same time however; some modems require
* a firmware reload or other reinitialization to switch between eg
* CDMA/EVDO and GSM/UMTS.
*/
get modemCapabilities(): DeviceModemCapabilities;
get operator_code(): string;
get operatorCode(): string;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
/**
* The access point name the modem is connected to.
* @returns the APN name or %NULL if disconnected
*/
get_apn(): string;
/**
* Returns a bitfield of the generic access technology families the modem
* supports without a firmware reload or reinitialization. This value
* represents the network types the modem can immediately connect to.
* @returns the generic access technology families the modem supports without a firmware reload or other reinitialization
*/
get_current_capabilities(): DeviceModemCapabilities;
/**
* An identifier used by the modem backend (ModemManager) that aims to
* uniquely identify the a device. Can be used to match a connection to a
* particular device.
* @returns a device-id string
*/
get_device_id(): string;
/**
* Returns a bitfield of the generic access technology families the modem
* supports. Not all capabilities are available concurrently however; some
* may require a firmware reload or reinitialization.
* @returns the generic access technology families the modem supports
*/
get_modem_capabilities(): DeviceModemCapabilities;
/**
* The MCC and MNC (concatenated) of the network the modem is connected to.
* @returns the operator code or %NULL if disconnected or not a 3GPP modem.
*/
get_operator_code(): string;
}
namespace DeviceOlpcMesh {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
active_channel: number;
activeChannel: number;
companion: DeviceWifi;
}
}
class DeviceOlpcMesh extends Device {
static $gtype: GObject.GType;
// Properties
/**
* The device's active channel.
*/
get active_channel(): number;
/**
* The device's active channel.
*/
get activeChannel(): number;
/**
* The companion device.
*/
get companion(): DeviceWifi;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
/**
* Returns the active channel of the #NMDeviceOlpcMesh device.
* @returns active channel of the device
*/
get_active_channel(): number;
/**
* Gets the companion device of the #NMDeviceOlpcMesh.
* @returns the companion of the device of %NULL
*/
get_companion(): DeviceWifi;
}
namespace DeviceOvsBridge {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
slaves: Device[];
}
}
class DeviceOvsBridge extends Device {
static $gtype: GObject.GType;
// Properties
/**
* Gets the ports currently attached as port to the device.
*/
get slaves(): Device[];
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
/**
* Gets the ports currently attached as port to `device`.
* @returns the #GPtrArray containing #NMDevices that are ports of @device. This is the internal copy used by the device, and must not be modified.
*/
get_slaves(): Device[];
}
namespace DeviceOvsInterface {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {}
}
class DeviceOvsInterface extends Device {
static $gtype: GObject.GType;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
}
namespace DeviceOvsPort {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
slaves: Device[];
}
}
class DeviceOvsPort extends Device {
static $gtype: GObject.GType;
// Properties
/**
* Gets the interfaces currently attached as port to the device.
*/
get slaves(): Device[];
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
/**
* Gets the interfaces currently attached as port to `device`.
* @returns the #GPtrArray containing #NMDevices that are ports of @device. This is the internal copy used by the device, and must not be modified.
*/
get_slaves(): Device[];
}
namespace DevicePpp {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {}
}
class DevicePpp extends Device {
static $gtype: GObject.GType;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
}
namespace DeviceTeam {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
carrier: boolean;
config: string;
slaves: Device[];
}
}
class DeviceTeam extends Device {
static $gtype: GObject.GType;
// Properties
/**
* Whether the device has carrier.
*/
get carrier(): boolean;
/**
* The current JSON configuration of the device.
*/
get config(): string;
/**
* The devices attached as port to the team device.
*/
get slaves(): Device[];
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
/**
* Whether the device has carrier.
* @returns %TRUE if the device has carrier
*/
get_carrier(): boolean;
/**
* Gets the current JSON configuration of the #NMDeviceTeam
* @returns the current configuration. This is the internal string used by the device, and must not be modified.
*/
get_config(): string;
/**
* Gets the devices currently attach as port to `device`.
* @returns the #GPtrArray containing #NMDevices that are ports of @device. This is the internal copy used by the device, and must not be modified.
*/
get_slaves(): Device[];
}
namespace DeviceTun {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
group: number;
mode: string;
multi_queue: boolean;
multiQueue: boolean;
no_pi: boolean;
noPi: boolean;
owner: number;
vnet_hdr: boolean;
vnetHdr: boolean;
}
}
class DeviceTun extends Device {
static $gtype: GObject.GType;
// Properties
/**
* The gid of the tunnel group, or -1 if it has no owner.
*/
get group(): number;
/**
* The tunnel mode, either "tun" or "tap".
*/
get mode(): string;
/**
* The tunnel's "TUN_TAP_MQ" flag; true if callers can connect to
* the tap device multiple times, for multiple send/receive
* queues.
*/
get multi_queue(): boolean;
/**
* The tunnel's "TUN_TAP_MQ" flag; true if callers can connect to
* the tap device multiple times, for multiple send/receive
* queues.
*/
get multiQueue(): boolean;
/**
* The tunnel's "TUN_NO_PI" flag; true if no protocol info is
* prepended to the tunnel packets.
*/
get no_pi(): boolean;
/**
* The tunnel's "TUN_NO_PI" flag; true if no protocol info is
* prepended to the tunnel packets.
*/
get noPi(): boolean;
/**
* The uid of the tunnel owner, or -1 if it has no owner.
*/
get owner(): number;
/**
* The tunnel's "TUN_VNET_HDR" flag; true if the tunnel packets
* include a virtio network header.
*/
get vnet_hdr(): boolean;
/**
* The tunnel's "TUN_VNET_HDR" flag; true if the tunnel packets
* include a virtio network header.
*/
get vnetHdr(): boolean;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
/**
* Gets the tunnel group.
* @returns the gid of the tunnel group, or -1 if it has no owner.
*/
get_group(): number;
/**
* Returns the TUN/TAP mode for the device.
* @returns 'tun' or 'tap'
*/
get_mode(): string;
/**
* Returns whether the #NMDeviceTun has the IFF_MULTI_QUEUE flag.
* @returns %TRUE if the device doesn't have the flag, %FALSE otherwise
*/
get_multi_queue(): boolean;
/**
* Returns whether the #NMDeviceTun has the IFF_NO_PI flag.
* @returns %TRUE if the device has the flag, %FALSE otherwise
*/
get_no_pi(): boolean;
/**
* Gets the tunnel owner.
* @returns the uid of the tunnel owner, or -1 if it has no owner.
*/
get_owner(): number;
/**
* Returns whether the #NMDeviceTun has the IFF_VNET_HDR flag.
* @returns %TRUE if the device has the flag, %FALSE otherwise
*/
get_vnet_hdr(): boolean;
}
namespace DeviceVeth {
// Constructor properties interface
interface ConstructorProps extends DeviceEthernet.ConstructorProps {
peer: Device;
}
}
class DeviceVeth extends DeviceEthernet {
static $gtype: GObject.GType;
// Properties
/**
* The device's peer device.
*/
get peer(): Device;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
get_peer(): Device;
}
namespace DeviceVlan {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
carrier: boolean;
parent: Device;
vlan_id: number;
vlanId: number;
}
}
class DeviceVlan extends Device {
static $gtype: GObject.GType;
// Properties
/**
* Whether the device has carrier.
*/
get carrier(): boolean;
/**
* The devices's parent device.
*/
get parent(): Device;
/**
* The device's VLAN ID.
*/
get vlan_id(): number;
/**
* The device's VLAN ID.
*/
get vlanId(): number;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
/**
* Whether the device has carrier.
* @returns %TRUE if the device has carrier
*/
get_carrier(): boolean;
get_parent(): Device;
get_vlan_id(): number;
}
namespace DeviceVrf {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
table: number;
}
}
class DeviceVrf extends Device {
static $gtype: GObject.GType;
// Properties
/**
* The device's VRF table.
*/
get table(): number;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
get_table(): number;
}
namespace DeviceVxlan {
// Constructor properties interface
interface ConstructorProps extends Device.ConstructorProps {
ageing: number;
carrier: boolean;
dst_port: number;
dstPort: number;
group: string;
id: number;
l2miss: boolean;
l3miss: boolean;
learning: boolean;
limit: number;
local: string;
parent: Device;
proxy: boolean;
rsc: boolean;
src_port_max: number;
srcPortMax: number;
src_port_min: number;
srcPortMin: number;
tos: number;
ttl: number;
}
}
class DeviceVxlan extends Device {
static $gtype: GObject.GType