
/* This file is generated by glib-mkenums, do not modify it. This code is licensed under the same license as the containing project. Note that it links to GLib, so must comply with the LGPL linking clauses. */

#include "libnm-core-impl/nm-default-libnm-core.h"
#include "nm-core-enum-types.h"
#include "nm-connection.h"
#include "nm-core-types.h"
#include "nm-dbus-interface.h"
#include "nm-errors.h"
#include "nm-keyfile.h"
#include "nm-setting-6lowpan.h"
#include "nm-setting-8021x.h"
#include "nm-setting-adsl.h"
#include "nm-setting-bluetooth.h"
#include "nm-setting-bond.h"
#include "nm-setting-bond-port.h"
#include "nm-setting-bridge-port.h"
#include "nm-setting-bridge.h"
#include "nm-setting-cdma.h"
#include "nm-setting-connection.h"
#include "nm-setting-dcb.h"
#include "nm-setting-dummy.h"
#include "nm-setting-ethtool.h"
#include "nm-setting-generic.h"
#include "nm-setting-gsm.h"
#include "nm-setting-hostname.h"
#include "nm-setting-infiniband.h"
#include "nm-setting-ip-config.h"
#include "nm-setting-ip-tunnel.h"
#include "nm-setting-ip4-config.h"
#include "nm-setting-ip6-config.h"
#include "nm-setting-macsec.h"
#include "nm-setting-macvlan.h"
#include "nm-setting-match.h"
#include "nm-setting-olpc-mesh.h"
#include "nm-setting-ovs-bridge.h"
#include "nm-setting-ovs-dpdk.h"
#include "nm-setting-ovs-external-ids.h"
#include "nm-setting-ovs-interface.h"
#include "nm-setting-ovs-patch.h"
#include "nm-setting-ovs-port.h"
#include "nm-setting-ppp.h"
#include "nm-setting-pppoe.h"
#include "nm-setting-proxy.h"
#include "nm-setting-serial.h"
#include "nm-setting-sriov.h"
#include "nm-setting-tc-config.h"
#include "nm-setting-team-port.h"
#include "nm-setting-team.h"
#include "nm-setting-tun.h"
#include "nm-setting-user.h"
#include "nm-setting-veth.h"
#include "nm-setting-vlan.h"
#include "nm-setting-vpn.h"
#include "nm-setting-vrf.h"
#include "nm-setting-vxlan.h"
#include "nm-setting-wifi-p2p.h"
#include "nm-setting-wimax.h"
#include "nm-setting-wired.h"
#include "nm-setting-wireguard.h"
#include "nm-setting-wireless-security.h"
#include "nm-setting-wireless.h"
#include "nm-setting-wpan.h"
#include "nm-setting.h"
#include "nm-simple-connection.h"
#include "nm-utils.h"
#include "nm-version.h"
#include "nm-vpn-dbus-interface.h"
#include "nm-vpn-editor-plugin.h"
#include "nm-vpn-plugin-info.h"
#include "nm-version-macros.h"

#define C_ENUM(v) ((gint) v)
#define C_FLAGS(v) ((guint) v)

/* enumerations from "nm-connection.h" */

GType
nm_connection_serialization_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_CONNECTION_SERIALIZE_ALL), "NM_CONNECTION_SERIALIZE_ALL", "all" },
    { C_FLAGS(NM_CONNECTION_SERIALIZE_WITH_NON_SECRET), "NM_CONNECTION_SERIALIZE_WITH_NON_SECRET", "with-non-secret" },
    { C_FLAGS(NM_CONNECTION_SERIALIZE_NO_SECRETS), "NM_CONNECTION_SERIALIZE_NO_SECRETS", "no-secrets" },
    { C_FLAGS(NM_CONNECTION_SERIALIZE_WITH_SECRETS), "NM_CONNECTION_SERIALIZE_WITH_SECRETS", "with-secrets" },
    { C_FLAGS(NM_CONNECTION_SERIALIZE_ONLY_SECRETS), "NM_CONNECTION_SERIALIZE_ONLY_SECRETS", "only-secrets" },
    { C_FLAGS(NM_CONNECTION_SERIALIZE_WITH_SECRETS_AGENT_OWNED), "NM_CONNECTION_SERIALIZE_WITH_SECRETS_AGENT_OWNED", "with-secrets-agent-owned" },
    { C_FLAGS(NM_CONNECTION_SERIALIZE_WITH_SECRETS_SYSTEM_OWNED), "NM_CONNECTION_SERIALIZE_WITH_SECRETS_SYSTEM_OWNED", "with-secrets-system-owned" },
    { C_FLAGS(NM_CONNECTION_SERIALIZE_WITH_SECRETS_NOT_SAVED), "NM_CONNECTION_SERIALIZE_WITH_SECRETS_NOT_SAVED", "with-secrets-not-saved" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMConnectionSerializationFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-dbus-interface.h" */

GType
nm_capability_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_CAPABILITY_TEAM), "NM_CAPABILITY_TEAM", "team" },
    { C_ENUM(NM_CAPABILITY_OVS), "NM_CAPABILITY_OVS", "ovs" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMCapability"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_state_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_STATE_UNKNOWN), "NM_STATE_UNKNOWN", "unknown" },
    { C_ENUM(NM_STATE_ASLEEP), "NM_STATE_ASLEEP", "asleep" },
    { C_ENUM(NM_STATE_DISCONNECTED), "NM_STATE_DISCONNECTED", "disconnected" },
    { C_ENUM(NM_STATE_DISCONNECTING), "NM_STATE_DISCONNECTING", "disconnecting" },
    { C_ENUM(NM_STATE_CONNECTING), "NM_STATE_CONNECTING", "connecting" },
    { C_ENUM(NM_STATE_CONNECTED_LOCAL), "NM_STATE_CONNECTED_LOCAL", "connected-local" },
    { C_ENUM(NM_STATE_CONNECTED_SITE), "NM_STATE_CONNECTED_SITE", "connected-site" },
    { C_ENUM(NM_STATE_CONNECTED_GLOBAL), "NM_STATE_CONNECTED_GLOBAL", "connected-global" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMState"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_connectivity_state_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_CONNECTIVITY_UNKNOWN), "NM_CONNECTIVITY_UNKNOWN", "unknown" },
    { C_ENUM(NM_CONNECTIVITY_NONE), "NM_CONNECTIVITY_NONE", "none" },
    { C_ENUM(NM_CONNECTIVITY_PORTAL), "NM_CONNECTIVITY_PORTAL", "portal" },
    { C_ENUM(NM_CONNECTIVITY_LIMITED), "NM_CONNECTIVITY_LIMITED", "limited" },
    { C_ENUM(NM_CONNECTIVITY_FULL), "NM_CONNECTIVITY_FULL", "full" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMConnectivityState"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_device_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_DEVICE_TYPE_UNKNOWN), "NM_DEVICE_TYPE_UNKNOWN", "unknown" },
    { C_ENUM(NM_DEVICE_TYPE_ETHERNET), "NM_DEVICE_TYPE_ETHERNET", "ethernet" },
    { C_ENUM(NM_DEVICE_TYPE_WIFI), "NM_DEVICE_TYPE_WIFI", "wifi" },
    { C_ENUM(NM_DEVICE_TYPE_UNUSED1), "NM_DEVICE_TYPE_UNUSED1", "unused1" },
    { C_ENUM(NM_DEVICE_TYPE_UNUSED2), "NM_DEVICE_TYPE_UNUSED2", "unused2" },
    { C_ENUM(NM_DEVICE_TYPE_BT), "NM_DEVICE_TYPE_BT", "bt" },
    { C_ENUM(NM_DEVICE_TYPE_OLPC_MESH), "NM_DEVICE_TYPE_OLPC_MESH", "olpc-mesh" },
    { C_ENUM(NM_DEVICE_TYPE_WIMAX), "NM_DEVICE_TYPE_WIMAX", "wimax" },
    { C_ENUM(NM_DEVICE_TYPE_MODEM), "NM_DEVICE_TYPE_MODEM", "modem" },
    { C_ENUM(NM_DEVICE_TYPE_INFINIBAND), "NM_DEVICE_TYPE_INFINIBAND", "infiniband" },
    { C_ENUM(NM_DEVICE_TYPE_BOND), "NM_DEVICE_TYPE_BOND", "bond" },
    { C_ENUM(NM_DEVICE_TYPE_VLAN), "NM_DEVICE_TYPE_VLAN", "vlan" },
    { C_ENUM(NM_DEVICE_TYPE_ADSL), "NM_DEVICE_TYPE_ADSL", "adsl" },
    { C_ENUM(NM_DEVICE_TYPE_BRIDGE), "NM_DEVICE_TYPE_BRIDGE", "bridge" },
    { C_ENUM(NM_DEVICE_TYPE_GENERIC), "NM_DEVICE_TYPE_GENERIC", "generic" },
    { C_ENUM(NM_DEVICE_TYPE_TEAM), "NM_DEVICE_TYPE_TEAM", "team" },
    { C_ENUM(NM_DEVICE_TYPE_TUN), "NM_DEVICE_TYPE_TUN", "tun" },
    { C_ENUM(NM_DEVICE_TYPE_IP_TUNNEL), "NM_DEVICE_TYPE_IP_TUNNEL", "ip-tunnel" },
    { C_ENUM(NM_DEVICE_TYPE_MACVLAN), "NM_DEVICE_TYPE_MACVLAN", "macvlan" },
    { C_ENUM(NM_DEVICE_TYPE_VXLAN), "NM_DEVICE_TYPE_VXLAN", "vxlan" },
    { C_ENUM(NM_DEVICE_TYPE_VETH), "NM_DEVICE_TYPE_VETH", "veth" },
    { C_ENUM(NM_DEVICE_TYPE_MACSEC), "NM_DEVICE_TYPE_MACSEC", "macsec" },
    { C_ENUM(NM_DEVICE_TYPE_DUMMY), "NM_DEVICE_TYPE_DUMMY", "dummy" },
    { C_ENUM(NM_DEVICE_TYPE_PPP), "NM_DEVICE_TYPE_PPP", "ppp" },
    { C_ENUM(NM_DEVICE_TYPE_OVS_INTERFACE), "NM_DEVICE_TYPE_OVS_INTERFACE", "ovs-interface" },
    { C_ENUM(NM_DEVICE_TYPE_OVS_PORT), "NM_DEVICE_TYPE_OVS_PORT", "ovs-port" },
    { C_ENUM(NM_DEVICE_TYPE_OVS_BRIDGE), "NM_DEVICE_TYPE_OVS_BRIDGE", "ovs-bridge" },
    { C_ENUM(NM_DEVICE_TYPE_WPAN), "NM_DEVICE_TYPE_WPAN", "wpan" },
    { C_ENUM(NM_DEVICE_TYPE_6LOWPAN), "NM_DEVICE_TYPE_6LOWPAN", "6lowpan" },
    { C_ENUM(NM_DEVICE_TYPE_WIREGUARD), "NM_DEVICE_TYPE_WIREGUARD", "wireguard" },
    { C_ENUM(NM_DEVICE_TYPE_WIFI_P2P), "NM_DEVICE_TYPE_WIFI_P2P", "wifi-p2p" },
    { C_ENUM(NM_DEVICE_TYPE_VRF), "NM_DEVICE_TYPE_VRF", "vrf" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMDeviceType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_device_capabilities_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_DEVICE_CAP_NONE), "NM_DEVICE_CAP_NONE", "none" },
    { C_FLAGS(NM_DEVICE_CAP_NM_SUPPORTED), "NM_DEVICE_CAP_NM_SUPPORTED", "nm-supported" },
    { C_FLAGS(NM_DEVICE_CAP_CARRIER_DETECT), "NM_DEVICE_CAP_CARRIER_DETECT", "carrier-detect" },
    { C_FLAGS(NM_DEVICE_CAP_IS_SOFTWARE), "NM_DEVICE_CAP_IS_SOFTWARE", "is-software" },
    { C_FLAGS(NM_DEVICE_CAP_SRIOV), "NM_DEVICE_CAP_SRIOV", "sriov" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMDeviceCapabilities"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_device_wifi_capabilities_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_WIFI_DEVICE_CAP_NONE), "NM_WIFI_DEVICE_CAP_NONE", "none" },
    { C_FLAGS(NM_WIFI_DEVICE_CAP_CIPHER_WEP40), "NM_WIFI_DEVICE_CAP_CIPHER_WEP40", "cipher-wep40" },
    { C_FLAGS(NM_WIFI_DEVICE_CAP_CIPHER_WEP104), "NM_WIFI_DEVICE_CAP_CIPHER_WEP104", "cipher-wep104" },
    { C_FLAGS(NM_WIFI_DEVICE_CAP_CIPHER_TKIP), "NM_WIFI_DEVICE_CAP_CIPHER_TKIP", "cipher-tkip" },
    { C_FLAGS(NM_WIFI_DEVICE_CAP_CIPHER_CCMP), "NM_WIFI_DEVICE_CAP_CIPHER_CCMP", "cipher-ccmp" },
    { C_FLAGS(NM_WIFI_DEVICE_CAP_WPA), "NM_WIFI_DEVICE_CAP_WPA", "wpa" },
    { C_FLAGS(NM_WIFI_DEVICE_CAP_RSN), "NM_WIFI_DEVICE_CAP_RSN", "rsn" },
    { C_FLAGS(NM_WIFI_DEVICE_CAP_AP), "NM_WIFI_DEVICE_CAP_AP", "ap" },
    { C_FLAGS(NM_WIFI_DEVICE_CAP_ADHOC), "NM_WIFI_DEVICE_CAP_ADHOC", "adhoc" },
    { C_FLAGS(NM_WIFI_DEVICE_CAP_FREQ_VALID), "NM_WIFI_DEVICE_CAP_FREQ_VALID", "freq-valid" },
    { C_FLAGS(NM_WIFI_DEVICE_CAP_FREQ_2GHZ), "NM_WIFI_DEVICE_CAP_FREQ_2GHZ", "freq-2ghz" },
    { C_FLAGS(NM_WIFI_DEVICE_CAP_FREQ_5GHZ), "NM_WIFI_DEVICE_CAP_FREQ_5GHZ", "freq-5ghz" },
    { C_FLAGS(NM_WIFI_DEVICE_CAP_MESH), "NM_WIFI_DEVICE_CAP_MESH", "mesh" },
    { C_FLAGS(NM_WIFI_DEVICE_CAP_IBSS_RSN), "NM_WIFI_DEVICE_CAP_IBSS_RSN", "ibss-rsn" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMDeviceWifiCapabilities"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_802_11_ap_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_802_11_AP_FLAGS_NONE), "NM_802_11_AP_FLAGS_NONE", "none" },
    { C_FLAGS(NM_802_11_AP_FLAGS_PRIVACY), "NM_802_11_AP_FLAGS_PRIVACY", "privacy" },
    { C_FLAGS(NM_802_11_AP_FLAGS_WPS), "NM_802_11_AP_FLAGS_WPS", "wps" },
    { C_FLAGS(NM_802_11_AP_FLAGS_WPS_PBC), "NM_802_11_AP_FLAGS_WPS_PBC", "wps-pbc" },
    { C_FLAGS(NM_802_11_AP_FLAGS_WPS_PIN), "NM_802_11_AP_FLAGS_WPS_PIN", "wps-pin" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NM80211ApFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_802_11_ap_security_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_802_11_AP_SEC_NONE), "NM_802_11_AP_SEC_NONE", "none" },
    { C_FLAGS(NM_802_11_AP_SEC_PAIR_WEP40), "NM_802_11_AP_SEC_PAIR_WEP40", "pair-wep40" },
    { C_FLAGS(NM_802_11_AP_SEC_PAIR_WEP104), "NM_802_11_AP_SEC_PAIR_WEP104", "pair-wep104" },
    { C_FLAGS(NM_802_11_AP_SEC_PAIR_TKIP), "NM_802_11_AP_SEC_PAIR_TKIP", "pair-tkip" },
    { C_FLAGS(NM_802_11_AP_SEC_PAIR_CCMP), "NM_802_11_AP_SEC_PAIR_CCMP", "pair-ccmp" },
    { C_FLAGS(NM_802_11_AP_SEC_GROUP_WEP40), "NM_802_11_AP_SEC_GROUP_WEP40", "group-wep40" },
    { C_FLAGS(NM_802_11_AP_SEC_GROUP_WEP104), "NM_802_11_AP_SEC_GROUP_WEP104", "group-wep104" },
    { C_FLAGS(NM_802_11_AP_SEC_GROUP_TKIP), "NM_802_11_AP_SEC_GROUP_TKIP", "group-tkip" },
    { C_FLAGS(NM_802_11_AP_SEC_GROUP_CCMP), "NM_802_11_AP_SEC_GROUP_CCMP", "group-ccmp" },
    { C_FLAGS(NM_802_11_AP_SEC_KEY_MGMT_PSK), "NM_802_11_AP_SEC_KEY_MGMT_PSK", "key-mgmt-psk" },
    { C_FLAGS(NM_802_11_AP_SEC_KEY_MGMT_802_1X), "NM_802_11_AP_SEC_KEY_MGMT_802_1X", "key-mgmt-802-1x" },
    { C_FLAGS(NM_802_11_AP_SEC_KEY_MGMT_SAE), "NM_802_11_AP_SEC_KEY_MGMT_SAE", "key-mgmt-sae" },
    { C_FLAGS(NM_802_11_AP_SEC_KEY_MGMT_OWE), "NM_802_11_AP_SEC_KEY_MGMT_OWE", "key-mgmt-owe" },
    { C_FLAGS(NM_802_11_AP_SEC_KEY_MGMT_OWE_TM), "NM_802_11_AP_SEC_KEY_MGMT_OWE_TM", "key-mgmt-owe-tm" },
    { C_FLAGS(NM_802_11_AP_SEC_KEY_MGMT_EAP_SUITE_B_192), "NM_802_11_AP_SEC_KEY_MGMT_EAP_SUITE_B_192", "key-mgmt-eap-suite-b-192" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NM80211ApSecurityFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_802_11_mode_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_802_11_MODE_UNKNOWN), "NM_802_11_MODE_UNKNOWN", "unknown" },
    { C_ENUM(NM_802_11_MODE_ADHOC), "NM_802_11_MODE_ADHOC", "adhoc" },
    { C_ENUM(NM_802_11_MODE_INFRA), "NM_802_11_MODE_INFRA", "infra" },
    { C_ENUM(NM_802_11_MODE_AP), "NM_802_11_MODE_AP", "ap" },
    { C_ENUM(NM_802_11_MODE_MESH), "NM_802_11_MODE_MESH", "mesh" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NM80211Mode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_bluetooth_capabilities_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_BT_CAPABILITY_NONE), "NM_BT_CAPABILITY_NONE", "none" },
    { C_FLAGS(NM_BT_CAPABILITY_DUN), "NM_BT_CAPABILITY_DUN", "dun" },
    { C_FLAGS(NM_BT_CAPABILITY_NAP), "NM_BT_CAPABILITY_NAP", "nap" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMBluetoothCapabilities"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_device_modem_capabilities_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_DEVICE_MODEM_CAPABILITY_NONE), "NM_DEVICE_MODEM_CAPABILITY_NONE", "none" },
    { C_FLAGS(NM_DEVICE_MODEM_CAPABILITY_POTS), "NM_DEVICE_MODEM_CAPABILITY_POTS", "pots" },
    { C_FLAGS(NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO), "NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO", "cdma-evdo" },
    { C_FLAGS(NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS), "NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS", "gsm-umts" },
    { C_FLAGS(NM_DEVICE_MODEM_CAPABILITY_LTE), "NM_DEVICE_MODEM_CAPABILITY_LTE", "lte" },
    { C_FLAGS(NM_DEVICE_MODEM_CAPABILITY_5GNR), "NM_DEVICE_MODEM_CAPABILITY_5GNR", "5gnr" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMDeviceModemCapabilities"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_wimax_nsp_network_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_WIMAX_NSP_NETWORK_TYPE_UNKNOWN), "NM_WIMAX_NSP_NETWORK_TYPE_UNKNOWN", "unknown" },
    { C_ENUM(NM_WIMAX_NSP_NETWORK_TYPE_HOME), "NM_WIMAX_NSP_NETWORK_TYPE_HOME", "home" },
    { C_ENUM(NM_WIMAX_NSP_NETWORK_TYPE_PARTNER), "NM_WIMAX_NSP_NETWORK_TYPE_PARTNER", "partner" },
    { C_ENUM(NM_WIMAX_NSP_NETWORK_TYPE_ROAMING_PARTNER), "NM_WIMAX_NSP_NETWORK_TYPE_ROAMING_PARTNER", "roaming-partner" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMWimaxNspNetworkType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_device_state_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_DEVICE_STATE_UNKNOWN), "NM_DEVICE_STATE_UNKNOWN", "unknown" },
    { C_ENUM(NM_DEVICE_STATE_UNMANAGED), "NM_DEVICE_STATE_UNMANAGED", "unmanaged" },
    { C_ENUM(NM_DEVICE_STATE_UNAVAILABLE), "NM_DEVICE_STATE_UNAVAILABLE", "unavailable" },
    { C_ENUM(NM_DEVICE_STATE_DISCONNECTED), "NM_DEVICE_STATE_DISCONNECTED", "disconnected" },
    { C_ENUM(NM_DEVICE_STATE_PREPARE), "NM_DEVICE_STATE_PREPARE", "prepare" },
    { C_ENUM(NM_DEVICE_STATE_CONFIG), "NM_DEVICE_STATE_CONFIG", "config" },
    { C_ENUM(NM_DEVICE_STATE_NEED_AUTH), "NM_DEVICE_STATE_NEED_AUTH", "need-auth" },
    { C_ENUM(NM_DEVICE_STATE_IP_CONFIG), "NM_DEVICE_STATE_IP_CONFIG", "ip-config" },
    { C_ENUM(NM_DEVICE_STATE_IP_CHECK), "NM_DEVICE_STATE_IP_CHECK", "ip-check" },
    { C_ENUM(NM_DEVICE_STATE_SECONDARIES), "NM_DEVICE_STATE_SECONDARIES", "secondaries" },
    { C_ENUM(NM_DEVICE_STATE_ACTIVATED), "NM_DEVICE_STATE_ACTIVATED", "activated" },
    { C_ENUM(NM_DEVICE_STATE_DEACTIVATING), "NM_DEVICE_STATE_DEACTIVATING", "deactivating" },
    { C_ENUM(NM_DEVICE_STATE_FAILED), "NM_DEVICE_STATE_FAILED", "failed" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMDeviceState"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_device_state_reason_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_DEVICE_STATE_REASON_NONE), "NM_DEVICE_STATE_REASON_NONE", "none" },
    { C_ENUM(NM_DEVICE_STATE_REASON_UNKNOWN), "NM_DEVICE_STATE_REASON_UNKNOWN", "unknown" },
    { C_ENUM(NM_DEVICE_STATE_REASON_NOW_MANAGED), "NM_DEVICE_STATE_REASON_NOW_MANAGED", "now-managed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_NOW_UNMANAGED), "NM_DEVICE_STATE_REASON_NOW_UNMANAGED", "now-unmanaged" },
    { C_ENUM(NM_DEVICE_STATE_REASON_CONFIG_FAILED), "NM_DEVICE_STATE_REASON_CONFIG_FAILED", "config-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE), "NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE", "ip-config-unavailable" },
    { C_ENUM(NM_DEVICE_STATE_REASON_IP_CONFIG_EXPIRED), "NM_DEVICE_STATE_REASON_IP_CONFIG_EXPIRED", "ip-config-expired" },
    { C_ENUM(NM_DEVICE_STATE_REASON_NO_SECRETS), "NM_DEVICE_STATE_REASON_NO_SECRETS", "no-secrets" },
    { C_ENUM(NM_DEVICE_STATE_REASON_SUPPLICANT_DISCONNECT), "NM_DEVICE_STATE_REASON_SUPPLICANT_DISCONNECT", "supplicant-disconnect" },
    { C_ENUM(NM_DEVICE_STATE_REASON_SUPPLICANT_CONFIG_FAILED), "NM_DEVICE_STATE_REASON_SUPPLICANT_CONFIG_FAILED", "supplicant-config-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED), "NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED", "supplicant-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_SUPPLICANT_TIMEOUT), "NM_DEVICE_STATE_REASON_SUPPLICANT_TIMEOUT", "supplicant-timeout" },
    { C_ENUM(NM_DEVICE_STATE_REASON_PPP_START_FAILED), "NM_DEVICE_STATE_REASON_PPP_START_FAILED", "ppp-start-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_PPP_DISCONNECT), "NM_DEVICE_STATE_REASON_PPP_DISCONNECT", "ppp-disconnect" },
    { C_ENUM(NM_DEVICE_STATE_REASON_PPP_FAILED), "NM_DEVICE_STATE_REASON_PPP_FAILED", "ppp-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_DHCP_START_FAILED), "NM_DEVICE_STATE_REASON_DHCP_START_FAILED", "dhcp-start-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_DHCP_ERROR), "NM_DEVICE_STATE_REASON_DHCP_ERROR", "dhcp-error" },
    { C_ENUM(NM_DEVICE_STATE_REASON_DHCP_FAILED), "NM_DEVICE_STATE_REASON_DHCP_FAILED", "dhcp-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_SHARED_START_FAILED), "NM_DEVICE_STATE_REASON_SHARED_START_FAILED", "shared-start-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_SHARED_FAILED), "NM_DEVICE_STATE_REASON_SHARED_FAILED", "shared-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_AUTOIP_START_FAILED), "NM_DEVICE_STATE_REASON_AUTOIP_START_FAILED", "autoip-start-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_AUTOIP_ERROR), "NM_DEVICE_STATE_REASON_AUTOIP_ERROR", "autoip-error" },
    { C_ENUM(NM_DEVICE_STATE_REASON_AUTOIP_FAILED), "NM_DEVICE_STATE_REASON_AUTOIP_FAILED", "autoip-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_MODEM_BUSY), "NM_DEVICE_STATE_REASON_MODEM_BUSY", "modem-busy" },
    { C_ENUM(NM_DEVICE_STATE_REASON_MODEM_NO_DIAL_TONE), "NM_DEVICE_STATE_REASON_MODEM_NO_DIAL_TONE", "modem-no-dial-tone" },
    { C_ENUM(NM_DEVICE_STATE_REASON_MODEM_NO_CARRIER), "NM_DEVICE_STATE_REASON_MODEM_NO_CARRIER", "modem-no-carrier" },
    { C_ENUM(NM_DEVICE_STATE_REASON_MODEM_DIAL_TIMEOUT), "NM_DEVICE_STATE_REASON_MODEM_DIAL_TIMEOUT", "modem-dial-timeout" },
    { C_ENUM(NM_DEVICE_STATE_REASON_MODEM_DIAL_FAILED), "NM_DEVICE_STATE_REASON_MODEM_DIAL_FAILED", "modem-dial-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_MODEM_INIT_FAILED), "NM_DEVICE_STATE_REASON_MODEM_INIT_FAILED", "modem-init-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_GSM_APN_FAILED), "NM_DEVICE_STATE_REASON_GSM_APN_FAILED", "gsm-apn-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_GSM_REGISTRATION_NOT_SEARCHING), "NM_DEVICE_STATE_REASON_GSM_REGISTRATION_NOT_SEARCHING", "gsm-registration-not-searching" },
    { C_ENUM(NM_DEVICE_STATE_REASON_GSM_REGISTRATION_DENIED), "NM_DEVICE_STATE_REASON_GSM_REGISTRATION_DENIED", "gsm-registration-denied" },
    { C_ENUM(NM_DEVICE_STATE_REASON_GSM_REGISTRATION_TIMEOUT), "NM_DEVICE_STATE_REASON_GSM_REGISTRATION_TIMEOUT", "gsm-registration-timeout" },
    { C_ENUM(NM_DEVICE_STATE_REASON_GSM_REGISTRATION_FAILED), "NM_DEVICE_STATE_REASON_GSM_REGISTRATION_FAILED", "gsm-registration-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_GSM_PIN_CHECK_FAILED), "NM_DEVICE_STATE_REASON_GSM_PIN_CHECK_FAILED", "gsm-pin-check-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_FIRMWARE_MISSING), "NM_DEVICE_STATE_REASON_FIRMWARE_MISSING", "firmware-missing" },
    { C_ENUM(NM_DEVICE_STATE_REASON_REMOVED), "NM_DEVICE_STATE_REASON_REMOVED", "removed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_SLEEPING), "NM_DEVICE_STATE_REASON_SLEEPING", "sleeping" },
    { C_ENUM(NM_DEVICE_STATE_REASON_CONNECTION_REMOVED), "NM_DEVICE_STATE_REASON_CONNECTION_REMOVED", "connection-removed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_USER_REQUESTED), "NM_DEVICE_STATE_REASON_USER_REQUESTED", "user-requested" },
    { C_ENUM(NM_DEVICE_STATE_REASON_CARRIER), "NM_DEVICE_STATE_REASON_CARRIER", "carrier" },
    { C_ENUM(NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED), "NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED", "connection-assumed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_SUPPLICANT_AVAILABLE), "NM_DEVICE_STATE_REASON_SUPPLICANT_AVAILABLE", "supplicant-available" },
    { C_ENUM(NM_DEVICE_STATE_REASON_MODEM_NOT_FOUND), "NM_DEVICE_STATE_REASON_MODEM_NOT_FOUND", "modem-not-found" },
    { C_ENUM(NM_DEVICE_STATE_REASON_BT_FAILED), "NM_DEVICE_STATE_REASON_BT_FAILED", "bt-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_GSM_SIM_NOT_INSERTED), "NM_DEVICE_STATE_REASON_GSM_SIM_NOT_INSERTED", "gsm-sim-not-inserted" },
    { C_ENUM(NM_DEVICE_STATE_REASON_GSM_SIM_PIN_REQUIRED), "NM_DEVICE_STATE_REASON_GSM_SIM_PIN_REQUIRED", "gsm-sim-pin-required" },
    { C_ENUM(NM_DEVICE_STATE_REASON_GSM_SIM_PUK_REQUIRED), "NM_DEVICE_STATE_REASON_GSM_SIM_PUK_REQUIRED", "gsm-sim-puk-required" },
    { C_ENUM(NM_DEVICE_STATE_REASON_GSM_SIM_WRONG), "NM_DEVICE_STATE_REASON_GSM_SIM_WRONG", "gsm-sim-wrong" },
    { C_ENUM(NM_DEVICE_STATE_REASON_INFINIBAND_MODE), "NM_DEVICE_STATE_REASON_INFINIBAND_MODE", "infiniband-mode" },
    { C_ENUM(NM_DEVICE_STATE_REASON_DEPENDENCY_FAILED), "NM_DEVICE_STATE_REASON_DEPENDENCY_FAILED", "dependency-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_BR2684_FAILED), "NM_DEVICE_STATE_REASON_BR2684_FAILED", "br2684-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_MODEM_MANAGER_UNAVAILABLE), "NM_DEVICE_STATE_REASON_MODEM_MANAGER_UNAVAILABLE", "modem-manager-unavailable" },
    { C_ENUM(NM_DEVICE_STATE_REASON_SSID_NOT_FOUND), "NM_DEVICE_STATE_REASON_SSID_NOT_FOUND", "ssid-not-found" },
    { C_ENUM(NM_DEVICE_STATE_REASON_SECONDARY_CONNECTION_FAILED), "NM_DEVICE_STATE_REASON_SECONDARY_CONNECTION_FAILED", "secondary-connection-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_DCB_FCOE_FAILED), "NM_DEVICE_STATE_REASON_DCB_FCOE_FAILED", "dcb-fcoe-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_TEAMD_CONTROL_FAILED), "NM_DEVICE_STATE_REASON_TEAMD_CONTROL_FAILED", "teamd-control-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_MODEM_FAILED), "NM_DEVICE_STATE_REASON_MODEM_FAILED", "modem-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_MODEM_AVAILABLE), "NM_DEVICE_STATE_REASON_MODEM_AVAILABLE", "modem-available" },
    { C_ENUM(NM_DEVICE_STATE_REASON_SIM_PIN_INCORRECT), "NM_DEVICE_STATE_REASON_SIM_PIN_INCORRECT", "sim-pin-incorrect" },
    { C_ENUM(NM_DEVICE_STATE_REASON_NEW_ACTIVATION), "NM_DEVICE_STATE_REASON_NEW_ACTIVATION", "new-activation" },
    { C_ENUM(NM_DEVICE_STATE_REASON_PARENT_CHANGED), "NM_DEVICE_STATE_REASON_PARENT_CHANGED", "parent-changed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_PARENT_MANAGED_CHANGED), "NM_DEVICE_STATE_REASON_PARENT_MANAGED_CHANGED", "parent-managed-changed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_OVSDB_FAILED), "NM_DEVICE_STATE_REASON_OVSDB_FAILED", "ovsdb-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_IP_ADDRESS_DUPLICATE), "NM_DEVICE_STATE_REASON_IP_ADDRESS_DUPLICATE", "ip-address-duplicate" },
    { C_ENUM(NM_DEVICE_STATE_REASON_IP_METHOD_UNSUPPORTED), "NM_DEVICE_STATE_REASON_IP_METHOD_UNSUPPORTED", "ip-method-unsupported" },
    { C_ENUM(NM_DEVICE_STATE_REASON_SRIOV_CONFIGURATION_FAILED), "NM_DEVICE_STATE_REASON_SRIOV_CONFIGURATION_FAILED", "sriov-configuration-failed" },
    { C_ENUM(NM_DEVICE_STATE_REASON_PEER_NOT_FOUND), "NM_DEVICE_STATE_REASON_PEER_NOT_FOUND", "peer-not-found" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMDeviceStateReason"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_metered_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_METERED_UNKNOWN), "NM_METERED_UNKNOWN", "unknown" },
    { C_ENUM(NM_METERED_YES), "NM_METERED_YES", "yes" },
    { C_ENUM(NM_METERED_NO), "NM_METERED_NO", "no" },
    { C_ENUM(NM_METERED_GUESS_YES), "NM_METERED_GUESS_YES", "guess-yes" },
    { C_ENUM(NM_METERED_GUESS_NO), "NM_METERED_GUESS_NO", "guess-no" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMMetered"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_connection_multi_connect_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_CONNECTION_MULTI_CONNECT_DEFAULT), "NM_CONNECTION_MULTI_CONNECT_DEFAULT", "default" },
    { C_ENUM(NM_CONNECTION_MULTI_CONNECT_SINGLE), "NM_CONNECTION_MULTI_CONNECT_SINGLE", "single" },
    { C_ENUM(NM_CONNECTION_MULTI_CONNECT_MANUAL_MULTIPLE), "NM_CONNECTION_MULTI_CONNECT_MANUAL_MULTIPLE", "manual-multiple" },
    { C_ENUM(NM_CONNECTION_MULTI_CONNECT_MULTIPLE), "NM_CONNECTION_MULTI_CONNECT_MULTIPLE", "multiple" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMConnectionMultiConnect"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_active_connection_state_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_ACTIVE_CONNECTION_STATE_UNKNOWN), "NM_ACTIVE_CONNECTION_STATE_UNKNOWN", "unknown" },
    { C_ENUM(NM_ACTIVE_CONNECTION_STATE_ACTIVATING), "NM_ACTIVE_CONNECTION_STATE_ACTIVATING", "activating" },
    { C_ENUM(NM_ACTIVE_CONNECTION_STATE_ACTIVATED), "NM_ACTIVE_CONNECTION_STATE_ACTIVATED", "activated" },
    { C_ENUM(NM_ACTIVE_CONNECTION_STATE_DEACTIVATING), "NM_ACTIVE_CONNECTION_STATE_DEACTIVATING", "deactivating" },
    { C_ENUM(NM_ACTIVE_CONNECTION_STATE_DEACTIVATED), "NM_ACTIVE_CONNECTION_STATE_DEACTIVATED", "deactivated" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMActiveConnectionState"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_active_connection_state_reason_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_ACTIVE_CONNECTION_STATE_REASON_UNKNOWN), "NM_ACTIVE_CONNECTION_STATE_REASON_UNKNOWN", "unknown" },
    { C_ENUM(NM_ACTIVE_CONNECTION_STATE_REASON_NONE), "NM_ACTIVE_CONNECTION_STATE_REASON_NONE", "none" },
    { C_ENUM(NM_ACTIVE_CONNECTION_STATE_REASON_USER_DISCONNECTED), "NM_ACTIVE_CONNECTION_STATE_REASON_USER_DISCONNECTED", "user-disconnected" },
    { C_ENUM(NM_ACTIVE_CONNECTION_STATE_REASON_DEVICE_DISCONNECTED), "NM_ACTIVE_CONNECTION_STATE_REASON_DEVICE_DISCONNECTED", "device-disconnected" },
    { C_ENUM(NM_ACTIVE_CONNECTION_STATE_REASON_SERVICE_STOPPED), "NM_ACTIVE_CONNECTION_STATE_REASON_SERVICE_STOPPED", "service-stopped" },
    { C_ENUM(NM_ACTIVE_CONNECTION_STATE_REASON_IP_CONFIG_INVALID), "NM_ACTIVE_CONNECTION_STATE_REASON_IP_CONFIG_INVALID", "ip-config-invalid" },
    { C_ENUM(NM_ACTIVE_CONNECTION_STATE_REASON_CONNECT_TIMEOUT), "NM_ACTIVE_CONNECTION_STATE_REASON_CONNECT_TIMEOUT", "connect-timeout" },
    { C_ENUM(NM_ACTIVE_CONNECTION_STATE_REASON_SERVICE_START_TIMEOUT), "NM_ACTIVE_CONNECTION_STATE_REASON_SERVICE_START_TIMEOUT", "service-start-timeout" },
    { C_ENUM(NM_ACTIVE_CONNECTION_STATE_REASON_SERVICE_START_FAILED), "NM_ACTIVE_CONNECTION_STATE_REASON_SERVICE_START_FAILED", "service-start-failed" },
    { C_ENUM(NM_ACTIVE_CONNECTION_STATE_REASON_NO_SECRETS), "NM_ACTIVE_CONNECTION_STATE_REASON_NO_SECRETS", "no-secrets" },
    { C_ENUM(NM_ACTIVE_CONNECTION_STATE_REASON_LOGIN_FAILED), "NM_ACTIVE_CONNECTION_STATE_REASON_LOGIN_FAILED", "login-failed" },
    { C_ENUM(NM_ACTIVE_CONNECTION_STATE_REASON_CONNECTION_REMOVED), "NM_ACTIVE_CONNECTION_STATE_REASON_CONNECTION_REMOVED", "connection-removed" },
    { C_ENUM(NM_ACTIVE_CONNECTION_STATE_REASON_DEPENDENCY_FAILED), "NM_ACTIVE_CONNECTION_STATE_REASON_DEPENDENCY_FAILED", "dependency-failed" },
    { C_ENUM(NM_ACTIVE_CONNECTION_STATE_REASON_DEVICE_REALIZE_FAILED), "NM_ACTIVE_CONNECTION_STATE_REASON_DEVICE_REALIZE_FAILED", "device-realize-failed" },
    { C_ENUM(NM_ACTIVE_CONNECTION_STATE_REASON_DEVICE_REMOVED), "NM_ACTIVE_CONNECTION_STATE_REASON_DEVICE_REMOVED", "device-removed" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMActiveConnectionStateReason"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_secret_agent_get_secrets_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_SECRET_AGENT_GET_SECRETS_FLAG_NONE), "NM_SECRET_AGENT_GET_SECRETS_FLAG_NONE", "none" },
    { C_FLAGS(NM_SECRET_AGENT_GET_SECRETS_FLAG_ALLOW_INTERACTION), "NM_SECRET_AGENT_GET_SECRETS_FLAG_ALLOW_INTERACTION", "allow-interaction" },
    { C_FLAGS(NM_SECRET_AGENT_GET_SECRETS_FLAG_REQUEST_NEW), "NM_SECRET_AGENT_GET_SECRETS_FLAG_REQUEST_NEW", "request-new" },
    { C_FLAGS(NM_SECRET_AGENT_GET_SECRETS_FLAG_USER_REQUESTED), "NM_SECRET_AGENT_GET_SECRETS_FLAG_USER_REQUESTED", "user-requested" },
    { C_FLAGS(NM_SECRET_AGENT_GET_SECRETS_FLAG_WPS_PBC_ACTIVE), "NM_SECRET_AGENT_GET_SECRETS_FLAG_WPS_PBC_ACTIVE", "wps-pbc-active" },
    { C_FLAGS(NM_SECRET_AGENT_GET_SECRETS_FLAG_ONLY_SYSTEM), "NM_SECRET_AGENT_GET_SECRETS_FLAG_ONLY_SYSTEM", "only-system" },
    { C_FLAGS(NM_SECRET_AGENT_GET_SECRETS_FLAG_NO_ERRORS), "NM_SECRET_AGENT_GET_SECRETS_FLAG_NO_ERRORS", "no-errors" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMSecretAgentGetSecretsFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_secret_agent_capabilities_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_SECRET_AGENT_CAPABILITY_NONE), "NM_SECRET_AGENT_CAPABILITY_NONE", "none" },
    { C_FLAGS(NM_SECRET_AGENT_CAPABILITY_VPN_HINTS), "NM_SECRET_AGENT_CAPABILITY_VPN_HINTS", "vpn-hints" },
    { C_FLAGS(NM_SECRET_AGENT_CAPABILITY_LAST), "NM_SECRET_AGENT_CAPABILITY_LAST", "last" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMSecretAgentCapabilities"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_ip_tunnel_mode_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_IP_TUNNEL_MODE_UNKNOWN), "NM_IP_TUNNEL_MODE_UNKNOWN", "unknown" },
    { C_ENUM(NM_IP_TUNNEL_MODE_IPIP), "NM_IP_TUNNEL_MODE_IPIP", "ipip" },
    { C_ENUM(NM_IP_TUNNEL_MODE_GRE), "NM_IP_TUNNEL_MODE_GRE", "gre" },
    { C_ENUM(NM_IP_TUNNEL_MODE_SIT), "NM_IP_TUNNEL_MODE_SIT", "sit" },
    { C_ENUM(NM_IP_TUNNEL_MODE_ISATAP), "NM_IP_TUNNEL_MODE_ISATAP", "isatap" },
    { C_ENUM(NM_IP_TUNNEL_MODE_VTI), "NM_IP_TUNNEL_MODE_VTI", "vti" },
    { C_ENUM(NM_IP_TUNNEL_MODE_IP6IP6), "NM_IP_TUNNEL_MODE_IP6IP6", "ip6ip6" },
    { C_ENUM(NM_IP_TUNNEL_MODE_IPIP6), "NM_IP_TUNNEL_MODE_IPIP6", "ipip6" },
    { C_ENUM(NM_IP_TUNNEL_MODE_IP6GRE), "NM_IP_TUNNEL_MODE_IP6GRE", "ip6gre" },
    { C_ENUM(NM_IP_TUNNEL_MODE_VTI6), "NM_IP_TUNNEL_MODE_VTI6", "vti6" },
    { C_ENUM(NM_IP_TUNNEL_MODE_GRETAP), "NM_IP_TUNNEL_MODE_GRETAP", "gretap" },
    { C_ENUM(NM_IP_TUNNEL_MODE_IP6GRETAP), "NM_IP_TUNNEL_MODE_IP6GRETAP", "ip6gretap" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMIPTunnelMode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_checkpoint_create_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_CHECKPOINT_CREATE_FLAG_NONE), "NM_CHECKPOINT_CREATE_FLAG_NONE", "none" },
    { C_FLAGS(NM_CHECKPOINT_CREATE_FLAG_DESTROY_ALL), "NM_CHECKPOINT_CREATE_FLAG_DESTROY_ALL", "destroy-all" },
    { C_FLAGS(NM_CHECKPOINT_CREATE_FLAG_DELETE_NEW_CONNECTIONS), "NM_CHECKPOINT_CREATE_FLAG_DELETE_NEW_CONNECTIONS", "delete-new-connections" },
    { C_FLAGS(NM_CHECKPOINT_CREATE_FLAG_DISCONNECT_NEW_DEVICES), "NM_CHECKPOINT_CREATE_FLAG_DISCONNECT_NEW_DEVICES", "disconnect-new-devices" },
    { C_FLAGS(NM_CHECKPOINT_CREATE_FLAG_ALLOW_OVERLAPPING), "NM_CHECKPOINT_CREATE_FLAG_ALLOW_OVERLAPPING", "allow-overlapping" },
    { C_FLAGS(NM_CHECKPOINT_CREATE_FLAG_NO_PRESERVE_EXTERNAL_PORTS), "NM_CHECKPOINT_CREATE_FLAG_NO_PRESERVE_EXTERNAL_PORTS", "no-preserve-external-ports" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMCheckpointCreateFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_settings_connection_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_SETTINGS_CONNECTION_FLAG_NONE), "NM_SETTINGS_CONNECTION_FLAG_NONE", "none" },
    { C_FLAGS(NM_SETTINGS_CONNECTION_FLAG_UNSAVED), "NM_SETTINGS_CONNECTION_FLAG_UNSAVED", "unsaved" },
    { C_FLAGS(NM_SETTINGS_CONNECTION_FLAG_NM_GENERATED), "NM_SETTINGS_CONNECTION_FLAG_NM_GENERATED", "nm-generated" },
    { C_FLAGS(NM_SETTINGS_CONNECTION_FLAG_VOLATILE), "NM_SETTINGS_CONNECTION_FLAG_VOLATILE", "volatile" },
    { C_FLAGS(NM_SETTINGS_CONNECTION_FLAG_EXTERNAL), "NM_SETTINGS_CONNECTION_FLAG_EXTERNAL", "external" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMSettingsConnectionFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_activation_state_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_ACTIVATION_STATE_FLAG_NONE), "NM_ACTIVATION_STATE_FLAG_NONE", "none" },
    { C_FLAGS(NM_ACTIVATION_STATE_FLAG_IS_MASTER), "NM_ACTIVATION_STATE_FLAG_IS_MASTER", "is-master" },
    { C_FLAGS(NM_ACTIVATION_STATE_FLAG_IS_SLAVE), "NM_ACTIVATION_STATE_FLAG_IS_SLAVE", "is-slave" },
    { C_FLAGS(NM_ACTIVATION_STATE_FLAG_LAYER2_READY), "NM_ACTIVATION_STATE_FLAG_LAYER2_READY", "layer2-ready" },
    { C_FLAGS(NM_ACTIVATION_STATE_FLAG_IP4_READY), "NM_ACTIVATION_STATE_FLAG_IP4_READY", "ip4-ready" },
    { C_FLAGS(NM_ACTIVATION_STATE_FLAG_IP6_READY), "NM_ACTIVATION_STATE_FLAG_IP6_READY", "ip6-ready" },
    { C_FLAGS(NM_ACTIVATION_STATE_FLAG_MASTER_HAS_SLAVES), "NM_ACTIVATION_STATE_FLAG_MASTER_HAS_SLAVES", "master-has-slaves" },
    { C_FLAGS(NM_ACTIVATION_STATE_FLAG_LIFETIME_BOUND_TO_PROFILE_VISIBILITY), "NM_ACTIVATION_STATE_FLAG_LIFETIME_BOUND_TO_PROFILE_VISIBILITY", "lifetime-bound-to-profile-visibility" },
    { C_FLAGS(NM_ACTIVATION_STATE_FLAG_EXTERNAL), "NM_ACTIVATION_STATE_FLAG_EXTERNAL", "external" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMActivationStateFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_settings_add_connection2_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_SETTINGS_ADD_CONNECTION2_FLAG_NONE), "NM_SETTINGS_ADD_CONNECTION2_FLAG_NONE", "none" },
    { C_FLAGS(NM_SETTINGS_ADD_CONNECTION2_FLAG_TO_DISK), "NM_SETTINGS_ADD_CONNECTION2_FLAG_TO_DISK", "to-disk" },
    { C_FLAGS(NM_SETTINGS_ADD_CONNECTION2_FLAG_IN_MEMORY), "NM_SETTINGS_ADD_CONNECTION2_FLAG_IN_MEMORY", "in-memory" },
    { C_FLAGS(NM_SETTINGS_ADD_CONNECTION2_FLAG_BLOCK_AUTOCONNECT), "NM_SETTINGS_ADD_CONNECTION2_FLAG_BLOCK_AUTOCONNECT", "block-autoconnect" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMSettingsAddConnection2Flags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_settings_update2_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_SETTINGS_UPDATE2_FLAG_NONE), "NM_SETTINGS_UPDATE2_FLAG_NONE", "none" },
    { C_FLAGS(NM_SETTINGS_UPDATE2_FLAG_TO_DISK), "NM_SETTINGS_UPDATE2_FLAG_TO_DISK", "to-disk" },
    { C_FLAGS(NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY), "NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY", "in-memory" },
    { C_FLAGS(NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY_DETACHED), "NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY_DETACHED", "in-memory-detached" },
    { C_FLAGS(NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY_ONLY), "NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY_ONLY", "in-memory-only" },
    { C_FLAGS(NM_SETTINGS_UPDATE2_FLAG_VOLATILE), "NM_SETTINGS_UPDATE2_FLAG_VOLATILE", "volatile" },
    { C_FLAGS(NM_SETTINGS_UPDATE2_FLAG_BLOCK_AUTOCONNECT), "NM_SETTINGS_UPDATE2_FLAG_BLOCK_AUTOCONNECT", "block-autoconnect" },
    { C_FLAGS(NM_SETTINGS_UPDATE2_FLAG_NO_REAPPLY), "NM_SETTINGS_UPDATE2_FLAG_NO_REAPPLY", "no-reapply" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMSettingsUpdate2Flags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_ternary_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_TERNARY_DEFAULT), "NM_TERNARY_DEFAULT", "default" },
    { C_ENUM(NM_TERNARY_FALSE), "NM_TERNARY_FALSE", "false" },
    { C_ENUM(NM_TERNARY_TRUE), "NM_TERNARY_TRUE", "true" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMTernary"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_manager_reload_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_MANAGER_RELOAD_FLAG_CONF), "NM_MANAGER_RELOAD_FLAG_CONF", "conf" },
    { C_FLAGS(NM_MANAGER_RELOAD_FLAG_DNS_RC), "NM_MANAGER_RELOAD_FLAG_DNS_RC", "dns-rc" },
    { C_FLAGS(NM_MANAGER_RELOAD_FLAG_DNS_FULL), "NM_MANAGER_RELOAD_FLAG_DNS_FULL", "dns-full" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMManagerReloadFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_device_interface_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_DEVICE_INTERFACE_FLAG_UP), "NM_DEVICE_INTERFACE_FLAG_UP", "up" },
    { C_FLAGS(NM_DEVICE_INTERFACE_FLAG_LOWER_UP), "NM_DEVICE_INTERFACE_FLAG_LOWER_UP", "lower-up" },
    { C_FLAGS(NM_DEVICE_INTERFACE_FLAG_PROMISC), "NM_DEVICE_INTERFACE_FLAG_PROMISC", "promisc" },
    { C_FLAGS(NM_DEVICE_INTERFACE_FLAG_CARRIER), "NM_DEVICE_INTERFACE_FLAG_CARRIER", "carrier" },
    { C_FLAGS(NM_DEVICE_INTERFACE_FLAG_LLDP_CLIENT_ENABLED), "NM_DEVICE_INTERFACE_FLAG_LLDP_CLIENT_ENABLED", "lldp-client-enabled" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMDeviceInterfaceFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_client_permission_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_CLIENT_PERMISSION_NONE), "NM_CLIENT_PERMISSION_NONE", "none" },
    { C_ENUM(NM_CLIENT_PERMISSION_ENABLE_DISABLE_NETWORK), "NM_CLIENT_PERMISSION_ENABLE_DISABLE_NETWORK", "enable-disable-network" },
    { C_ENUM(NM_CLIENT_PERMISSION_ENABLE_DISABLE_WIFI), "NM_CLIENT_PERMISSION_ENABLE_DISABLE_WIFI", "enable-disable-wifi" },
    { C_ENUM(NM_CLIENT_PERMISSION_ENABLE_DISABLE_WWAN), "NM_CLIENT_PERMISSION_ENABLE_DISABLE_WWAN", "enable-disable-wwan" },
    { C_ENUM(NM_CLIENT_PERMISSION_ENABLE_DISABLE_WIMAX), "NM_CLIENT_PERMISSION_ENABLE_DISABLE_WIMAX", "enable-disable-wimax" },
    { C_ENUM(NM_CLIENT_PERMISSION_SLEEP_WAKE), "NM_CLIENT_PERMISSION_SLEEP_WAKE", "sleep-wake" },
    { C_ENUM(NM_CLIENT_PERMISSION_NETWORK_CONTROL), "NM_CLIENT_PERMISSION_NETWORK_CONTROL", "network-control" },
    { C_ENUM(NM_CLIENT_PERMISSION_WIFI_SHARE_PROTECTED), "NM_CLIENT_PERMISSION_WIFI_SHARE_PROTECTED", "wifi-share-protected" },
    { C_ENUM(NM_CLIENT_PERMISSION_WIFI_SHARE_OPEN), "NM_CLIENT_PERMISSION_WIFI_SHARE_OPEN", "wifi-share-open" },
    { C_ENUM(NM_CLIENT_PERMISSION_SETTINGS_MODIFY_SYSTEM), "NM_CLIENT_PERMISSION_SETTINGS_MODIFY_SYSTEM", "settings-modify-system" },
    { C_ENUM(NM_CLIENT_PERMISSION_SETTINGS_MODIFY_OWN), "NM_CLIENT_PERMISSION_SETTINGS_MODIFY_OWN", "settings-modify-own" },
    { C_ENUM(NM_CLIENT_PERMISSION_SETTINGS_MODIFY_HOSTNAME), "NM_CLIENT_PERMISSION_SETTINGS_MODIFY_HOSTNAME", "settings-modify-hostname" },
    { C_ENUM(NM_CLIENT_PERMISSION_SETTINGS_MODIFY_GLOBAL_DNS), "NM_CLIENT_PERMISSION_SETTINGS_MODIFY_GLOBAL_DNS", "settings-modify-global-dns" },
    { C_ENUM(NM_CLIENT_PERMISSION_RELOAD), "NM_CLIENT_PERMISSION_RELOAD", "reload" },
    { C_ENUM(NM_CLIENT_PERMISSION_CHECKPOINT_ROLLBACK), "NM_CLIENT_PERMISSION_CHECKPOINT_ROLLBACK", "checkpoint-rollback" },
    { C_ENUM(NM_CLIENT_PERMISSION_ENABLE_DISABLE_STATISTICS), "NM_CLIENT_PERMISSION_ENABLE_DISABLE_STATISTICS", "enable-disable-statistics" },
    { C_ENUM(NM_CLIENT_PERMISSION_ENABLE_DISABLE_CONNECTIVITY_CHECK), "NM_CLIENT_PERMISSION_ENABLE_DISABLE_CONNECTIVITY_CHECK", "enable-disable-connectivity-check" },
    { C_ENUM(NM_CLIENT_PERMISSION_WIFI_SCAN), "NM_CLIENT_PERMISSION_WIFI_SCAN", "wifi-scan" },
    { C_ENUM(NM_CLIENT_PERMISSION_LAST), "NM_CLIENT_PERMISSION_LAST", "last" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMClientPermission"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_client_permission_result_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_CLIENT_PERMISSION_RESULT_UNKNOWN), "NM_CLIENT_PERMISSION_RESULT_UNKNOWN", "unknown" },
    { C_ENUM(NM_CLIENT_PERMISSION_RESULT_YES), "NM_CLIENT_PERMISSION_RESULT_YES", "yes" },
    { C_ENUM(NM_CLIENT_PERMISSION_RESULT_AUTH), "NM_CLIENT_PERMISSION_RESULT_AUTH", "auth" },
    { C_ENUM(NM_CLIENT_PERMISSION_RESULT_NO), "NM_CLIENT_PERMISSION_RESULT_NO", "no" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMClientPermissionResult"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_radio_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_RADIO_FLAG_NONE), "NM_RADIO_FLAG_NONE", "none" },
    { C_FLAGS(NM_RADIO_FLAG_WLAN_AVAILABLE), "NM_RADIO_FLAG_WLAN_AVAILABLE", "wlan-available" },
    { C_FLAGS(NM_RADIO_FLAG_WWAN_AVAILABLE), "NM_RADIO_FLAG_WWAN_AVAILABLE", "wwan-available" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMRadioFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-errors.h" */

GType
nm_agent_manager_error_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_AGENT_MANAGER_ERROR_FAILED), "NM_AGENT_MANAGER_ERROR_FAILED", "Failed" },
    { C_ENUM(NM_AGENT_MANAGER_ERROR_PERMISSION_DENIED), "NM_AGENT_MANAGER_ERROR_PERMISSION_DENIED", "PermissionDenied" },
    { C_ENUM(NM_AGENT_MANAGER_ERROR_INVALID_IDENTIFIER), "NM_AGENT_MANAGER_ERROR_INVALID_IDENTIFIER", "InvalidIdentifier" },
    { C_ENUM(NM_AGENT_MANAGER_ERROR_NOT_REGISTERED), "NM_AGENT_MANAGER_ERROR_NOT_REGISTERED", "NotRegistered" },
    { C_ENUM(NM_AGENT_MANAGER_ERROR_NO_SECRETS), "NM_AGENT_MANAGER_ERROR_NO_SECRETS", "NoSecrets" },
    { C_ENUM(NM_AGENT_MANAGER_ERROR_USER_CANCELED), "NM_AGENT_MANAGER_ERROR_USER_CANCELED", "UserCanceled" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMAgentManagerError"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_connection_error_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_CONNECTION_ERROR_FAILED), "NM_CONNECTION_ERROR_FAILED", "Failed" },
    { C_ENUM(NM_CONNECTION_ERROR_SETTING_NOT_FOUND), "NM_CONNECTION_ERROR_SETTING_NOT_FOUND", "SettingNotFound" },
    { C_ENUM(NM_CONNECTION_ERROR_PROPERTY_NOT_FOUND), "NM_CONNECTION_ERROR_PROPERTY_NOT_FOUND", "PropertyNotFound" },
    { C_ENUM(NM_CONNECTION_ERROR_PROPERTY_NOT_SECRET), "NM_CONNECTION_ERROR_PROPERTY_NOT_SECRET", "PropertyNotSecret" },
    { C_ENUM(NM_CONNECTION_ERROR_MISSING_SETTING), "NM_CONNECTION_ERROR_MISSING_SETTING", "MissingSetting" },
    { C_ENUM(NM_CONNECTION_ERROR_INVALID_SETTING), "NM_CONNECTION_ERROR_INVALID_SETTING", "InvalidSetting" },
    { C_ENUM(NM_CONNECTION_ERROR_MISSING_PROPERTY), "NM_CONNECTION_ERROR_MISSING_PROPERTY", "MissingProperty" },
    { C_ENUM(NM_CONNECTION_ERROR_INVALID_PROPERTY), "NM_CONNECTION_ERROR_INVALID_PROPERTY", "InvalidProperty" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMConnectionError"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_crypto_error_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_CRYPTO_ERROR_FAILED), "NM_CRYPTO_ERROR_FAILED", "failed" },
    { C_ENUM(NM_CRYPTO_ERROR_INVALID_DATA), "NM_CRYPTO_ERROR_INVALID_DATA", "invalid-data" },
    { C_ENUM(NM_CRYPTO_ERROR_INVALID_PASSWORD), "NM_CRYPTO_ERROR_INVALID_PASSWORD", "invalid-password" },
    { C_ENUM(NM_CRYPTO_ERROR_UNKNOWN_CIPHER), "NM_CRYPTO_ERROR_UNKNOWN_CIPHER", "unknown-cipher" },
    { C_ENUM(NM_CRYPTO_ERROR_DECRYPTION_FAILED), "NM_CRYPTO_ERROR_DECRYPTION_FAILED", "decryption-failed" },
    { C_ENUM(NM_CRYPTO_ERROR_ENCRYPTION_FAILED), "NM_CRYPTO_ERROR_ENCRYPTION_FAILED", "encryption-failed" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMCryptoError"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_device_error_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_DEVICE_ERROR_FAILED), "NM_DEVICE_ERROR_FAILED", "Failed" },
    { C_ENUM(NM_DEVICE_ERROR_CREATION_FAILED), "NM_DEVICE_ERROR_CREATION_FAILED", "CreationFailed" },
    { C_ENUM(NM_DEVICE_ERROR_INVALID_CONNECTION), "NM_DEVICE_ERROR_INVALID_CONNECTION", "InvalidConnection" },
    { C_ENUM(NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION), "NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION", "IncompatibleConnection" },
    { C_ENUM(NM_DEVICE_ERROR_NOT_ACTIVE), "NM_DEVICE_ERROR_NOT_ACTIVE", "NotActive" },
    { C_ENUM(NM_DEVICE_ERROR_NOT_SOFTWARE), "NM_DEVICE_ERROR_NOT_SOFTWARE", "NotSoftware" },
    { C_ENUM(NM_DEVICE_ERROR_NOT_ALLOWED), "NM_DEVICE_ERROR_NOT_ALLOWED", "NotAllowed" },
    { C_ENUM(NM_DEVICE_ERROR_SPECIFIC_OBJECT_NOT_FOUND), "NM_DEVICE_ERROR_SPECIFIC_OBJECT_NOT_FOUND", "SpecificObjectNotFound" },
    { C_ENUM(NM_DEVICE_ERROR_VERSION_ID_MISMATCH), "NM_DEVICE_ERROR_VERSION_ID_MISMATCH", "VersionIdMismatch" },
    { C_ENUM(NM_DEVICE_ERROR_MISSING_DEPENDENCIES), "NM_DEVICE_ERROR_MISSING_DEPENDENCIES", "MissingDependencies" },
    { C_ENUM(NM_DEVICE_ERROR_INVALID_ARGUMENT), "NM_DEVICE_ERROR_INVALID_ARGUMENT", "InvalidArgument" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMDeviceError"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_manager_error_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_MANAGER_ERROR_FAILED), "NM_MANAGER_ERROR_FAILED", "Failed" },
    { C_ENUM(NM_MANAGER_ERROR_PERMISSION_DENIED), "NM_MANAGER_ERROR_PERMISSION_DENIED", "PermissionDenied" },
    { C_ENUM(NM_MANAGER_ERROR_UNKNOWN_CONNECTION), "NM_MANAGER_ERROR_UNKNOWN_CONNECTION", "UnknownConnection" },
    { C_ENUM(NM_MANAGER_ERROR_UNKNOWN_DEVICE), "NM_MANAGER_ERROR_UNKNOWN_DEVICE", "UnknownDevice" },
    { C_ENUM(NM_MANAGER_ERROR_CONNECTION_NOT_AVAILABLE), "NM_MANAGER_ERROR_CONNECTION_NOT_AVAILABLE", "ConnectionNotAvailable" },
    { C_ENUM(NM_MANAGER_ERROR_CONNECTION_NOT_ACTIVE), "NM_MANAGER_ERROR_CONNECTION_NOT_ACTIVE", "ConnectionNotActive" },
    { C_ENUM(NM_MANAGER_ERROR_CONNECTION_ALREADY_ACTIVE), "NM_MANAGER_ERROR_CONNECTION_ALREADY_ACTIVE", "ConnectionAlreadyActive" },
    { C_ENUM(NM_MANAGER_ERROR_DEPENDENCY_FAILED), "NM_MANAGER_ERROR_DEPENDENCY_FAILED", "DependencyFailed" },
    { C_ENUM(NM_MANAGER_ERROR_ALREADY_ASLEEP_OR_AWAKE), "NM_MANAGER_ERROR_ALREADY_ASLEEP_OR_AWAKE", "AlreadyAsleepOrAwake" },
    { C_ENUM(NM_MANAGER_ERROR_ALREADY_ENABLED_OR_DISABLED), "NM_MANAGER_ERROR_ALREADY_ENABLED_OR_DISABLED", "AlreadyEnabledOrDisabled" },
    { C_ENUM(NM_MANAGER_ERROR_UNKNOWN_LOG_LEVEL), "NM_MANAGER_ERROR_UNKNOWN_LOG_LEVEL", "UnknownLogLevel" },
    { C_ENUM(NM_MANAGER_ERROR_UNKNOWN_LOG_DOMAIN), "NM_MANAGER_ERROR_UNKNOWN_LOG_DOMAIN", "UnknownLogDomain" },
    { C_ENUM(NM_MANAGER_ERROR_INVALID_ARGUMENTS), "NM_MANAGER_ERROR_INVALID_ARGUMENTS", "InvalidArguments" },
    { C_ENUM(NM_MANAGER_ERROR_MISSING_PLUGIN), "NM_MANAGER_ERROR_MISSING_PLUGIN", "MissingPlugin" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMManagerError"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_secret_agent_error_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SECRET_AGENT_ERROR_FAILED), "NM_SECRET_AGENT_ERROR_FAILED", "Failed" },
    { C_ENUM(NM_SECRET_AGENT_ERROR_PERMISSION_DENIED), "NM_SECRET_AGENT_ERROR_PERMISSION_DENIED", "PermissionDenied" },
    { C_ENUM(NM_SECRET_AGENT_ERROR_INVALID_CONNECTION), "NM_SECRET_AGENT_ERROR_INVALID_CONNECTION", "InvalidConnection" },
    { C_ENUM(NM_SECRET_AGENT_ERROR_USER_CANCELED), "NM_SECRET_AGENT_ERROR_USER_CANCELED", "UserCanceled" },
    { C_ENUM(NM_SECRET_AGENT_ERROR_AGENT_CANCELED), "NM_SECRET_AGENT_ERROR_AGENT_CANCELED", "AgentCanceled" },
    { C_ENUM(NM_SECRET_AGENT_ERROR_NO_SECRETS), "NM_SECRET_AGENT_ERROR_NO_SECRETS", "NoSecrets" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSecretAgentError"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_settings_error_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTINGS_ERROR_FAILED), "NM_SETTINGS_ERROR_FAILED", "Failed" },
    { C_ENUM(NM_SETTINGS_ERROR_PERMISSION_DENIED), "NM_SETTINGS_ERROR_PERMISSION_DENIED", "PermissionDenied" },
    { C_ENUM(NM_SETTINGS_ERROR_NOT_SUPPORTED), "NM_SETTINGS_ERROR_NOT_SUPPORTED", "NotSupported" },
    { C_ENUM(NM_SETTINGS_ERROR_INVALID_CONNECTION), "NM_SETTINGS_ERROR_INVALID_CONNECTION", "InvalidConnection" },
    { C_ENUM(NM_SETTINGS_ERROR_READ_ONLY_CONNECTION), "NM_SETTINGS_ERROR_READ_ONLY_CONNECTION", "ReadOnlyConnection" },
    { C_ENUM(NM_SETTINGS_ERROR_UUID_EXISTS), "NM_SETTINGS_ERROR_UUID_EXISTS", "UuidExists" },
    { C_ENUM(NM_SETTINGS_ERROR_INVALID_HOSTNAME), "NM_SETTINGS_ERROR_INVALID_HOSTNAME", "InvalidHostname" },
    { C_ENUM(NM_SETTINGS_ERROR_INVALID_ARGUMENTS), "NM_SETTINGS_ERROR_INVALID_ARGUMENTS", "InvalidArguments" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSettingsError"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_vpn_plugin_error_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_VPN_PLUGIN_ERROR_FAILED), "NM_VPN_PLUGIN_ERROR_FAILED", "Failed" },
    { C_ENUM(NM_VPN_PLUGIN_ERROR_STARTING_IN_PROGRESS), "NM_VPN_PLUGIN_ERROR_STARTING_IN_PROGRESS", "StartingInProgress" },
    { C_ENUM(NM_VPN_PLUGIN_ERROR_ALREADY_STARTED), "NM_VPN_PLUGIN_ERROR_ALREADY_STARTED", "AlreadyStarted" },
    { C_ENUM(NM_VPN_PLUGIN_ERROR_STOPPING_IN_PROGRESS), "NM_VPN_PLUGIN_ERROR_STOPPING_IN_PROGRESS", "StoppingInProgress" },
    { C_ENUM(NM_VPN_PLUGIN_ERROR_ALREADY_STOPPED), "NM_VPN_PLUGIN_ERROR_ALREADY_STOPPED", "AlreadyStopped" },
    { C_ENUM(NM_VPN_PLUGIN_ERROR_WRONG_STATE), "NM_VPN_PLUGIN_ERROR_WRONG_STATE", "WrongState" },
    { C_ENUM(NM_VPN_PLUGIN_ERROR_BAD_ARGUMENTS), "NM_VPN_PLUGIN_ERROR_BAD_ARGUMENTS", "BadArguments" },
    { C_ENUM(NM_VPN_PLUGIN_ERROR_LAUNCH_FAILED), "NM_VPN_PLUGIN_ERROR_LAUNCH_FAILED", "LaunchFailed" },
    { C_ENUM(NM_VPN_PLUGIN_ERROR_INVALID_CONNECTION), "NM_VPN_PLUGIN_ERROR_INVALID_CONNECTION", "InvalidConnection" },
    { C_ENUM(NM_VPN_PLUGIN_ERROR_INTERACTIVE_NOT_SUPPORTED), "NM_VPN_PLUGIN_ERROR_INTERACTIVE_NOT_SUPPORTED", "InteractiveNotSupported" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMVpnPluginError"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-keyfile.h" */

GType
nm_keyfile_handler_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_KEYFILE_HANDLER_FLAGS_NONE), "NM_KEYFILE_HANDLER_FLAGS_NONE", "none" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMKeyfileHandlerFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_keyfile_handler_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_KEYFILE_HANDLER_TYPE_WARN), "NM_KEYFILE_HANDLER_TYPE_WARN", "warn" },
    { C_ENUM(NM_KEYFILE_HANDLER_TYPE_WRITE_CERT), "NM_KEYFILE_HANDLER_TYPE_WRITE_CERT", "write-cert" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMKeyfileHandlerType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_keyfile_warn_severity_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_KEYFILE_WARN_SEVERITY_DEBUG), "NM_KEYFILE_WARN_SEVERITY_DEBUG", "debug" },
    { C_ENUM(NM_KEYFILE_WARN_SEVERITY_INFO), "NM_KEYFILE_WARN_SEVERITY_INFO", "info" },
    { C_ENUM(NM_KEYFILE_WARN_SEVERITY_INFO_MISSING_FILE), "NM_KEYFILE_WARN_SEVERITY_INFO_MISSING_FILE", "info-missing-file" },
    { C_ENUM(NM_KEYFILE_WARN_SEVERITY_WARN), "NM_KEYFILE_WARN_SEVERITY_WARN", "warn" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMKeyfileWarnSeverity"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-setting-8021x.h" */

GType
nm_setting_802_1x_ck_format_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_802_1X_CK_FORMAT_UNKNOWN), "NM_SETTING_802_1X_CK_FORMAT_UNKNOWN", "unknown" },
    { C_ENUM(NM_SETTING_802_1X_CK_FORMAT_X509), "NM_SETTING_802_1X_CK_FORMAT_X509", "x509" },
    { C_ENUM(NM_SETTING_802_1X_CK_FORMAT_RAW_KEY), "NM_SETTING_802_1X_CK_FORMAT_RAW_KEY", "raw-key" },
    { C_ENUM(NM_SETTING_802_1X_CK_FORMAT_PKCS12), "NM_SETTING_802_1X_CK_FORMAT_PKCS12", "pkcs12" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSetting8021xCKFormat"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_setting_802_1x_ck_scheme_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_802_1X_CK_SCHEME_UNKNOWN), "NM_SETTING_802_1X_CK_SCHEME_UNKNOWN", "unknown" },
    { C_ENUM(NM_SETTING_802_1X_CK_SCHEME_BLOB), "NM_SETTING_802_1X_CK_SCHEME_BLOB", "blob" },
    { C_ENUM(NM_SETTING_802_1X_CK_SCHEME_PATH), "NM_SETTING_802_1X_CK_SCHEME_PATH", "path" },
    { C_ENUM(NM_SETTING_802_1X_CK_SCHEME_PKCS11), "NM_SETTING_802_1X_CK_SCHEME_PKCS11", "pkcs11" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSetting8021xCKScheme"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_setting_802_1x_auth_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_SETTING_802_1X_AUTH_FLAGS_NONE), "NM_SETTING_802_1X_AUTH_FLAGS_NONE", "none" },
    { C_FLAGS(NM_SETTING_802_1X_AUTH_FLAGS_TLS_1_0_DISABLE), "NM_SETTING_802_1X_AUTH_FLAGS_TLS_1_0_DISABLE", "tls-1-0-disable" },
    { C_FLAGS(NM_SETTING_802_1X_AUTH_FLAGS_TLS_1_1_DISABLE), "NM_SETTING_802_1X_AUTH_FLAGS_TLS_1_1_DISABLE", "tls-1-1-disable" },
    { C_FLAGS(NM_SETTING_802_1X_AUTH_FLAGS_TLS_1_2_DISABLE), "NM_SETTING_802_1X_AUTH_FLAGS_TLS_1_2_DISABLE", "tls-1-2-disable" },
    { C_FLAGS(NM_SETTING_802_1X_AUTH_FLAGS_ALL), "NM_SETTING_802_1X_AUTH_FLAGS_ALL", "all" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMSetting8021xAuthFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-setting-connection.h" */

GType
nm_setting_connection_autoconnect_slaves_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES_DEFAULT), "NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES_DEFAULT", "default" },
    { C_ENUM(NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES_NO), "NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES_NO", "no" },
    { C_ENUM(NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES_YES), "NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES_YES", "yes" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSettingConnectionAutoconnectSlaves"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_setting_connection_lldp_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_CONNECTION_LLDP_DEFAULT), "NM_SETTING_CONNECTION_LLDP_DEFAULT", "default" },
    { C_ENUM(NM_SETTING_CONNECTION_LLDP_DISABLE), "NM_SETTING_CONNECTION_LLDP_DISABLE", "disable" },
    { C_ENUM(NM_SETTING_CONNECTION_LLDP_ENABLE_RX), "NM_SETTING_CONNECTION_LLDP_ENABLE_RX", "enable-rx" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSettingConnectionLldp"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_setting_connection_mdns_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_CONNECTION_MDNS_DEFAULT), "NM_SETTING_CONNECTION_MDNS_DEFAULT", "default" },
    { C_ENUM(NM_SETTING_CONNECTION_MDNS_NO), "NM_SETTING_CONNECTION_MDNS_NO", "no" },
    { C_ENUM(NM_SETTING_CONNECTION_MDNS_RESOLVE), "NM_SETTING_CONNECTION_MDNS_RESOLVE", "resolve" },
    { C_ENUM(NM_SETTING_CONNECTION_MDNS_YES), "NM_SETTING_CONNECTION_MDNS_YES", "yes" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSettingConnectionMdns"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_setting_connection_llmnr_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_CONNECTION_LLMNR_DEFAULT), "NM_SETTING_CONNECTION_LLMNR_DEFAULT", "default" },
    { C_ENUM(NM_SETTING_CONNECTION_LLMNR_NO), "NM_SETTING_CONNECTION_LLMNR_NO", "no" },
    { C_ENUM(NM_SETTING_CONNECTION_LLMNR_RESOLVE), "NM_SETTING_CONNECTION_LLMNR_RESOLVE", "resolve" },
    { C_ENUM(NM_SETTING_CONNECTION_LLMNR_YES), "NM_SETTING_CONNECTION_LLMNR_YES", "yes" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSettingConnectionLlmnr"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_setting_connection_dns_over_tls_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_CONNECTION_DNS_OVER_TLS_DEFAULT), "NM_SETTING_CONNECTION_DNS_OVER_TLS_DEFAULT", "default" },
    { C_ENUM(NM_SETTING_CONNECTION_DNS_OVER_TLS_NO), "NM_SETTING_CONNECTION_DNS_OVER_TLS_NO", "no" },
    { C_ENUM(NM_SETTING_CONNECTION_DNS_OVER_TLS_OPPORTUNISTIC), "NM_SETTING_CONNECTION_DNS_OVER_TLS_OPPORTUNISTIC", "opportunistic" },
    { C_ENUM(NM_SETTING_CONNECTION_DNS_OVER_TLS_YES), "NM_SETTING_CONNECTION_DNS_OVER_TLS_YES", "yes" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSettingConnectionDnsOverTls"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-setting-dcb.h" */

GType
nm_setting_dcb_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_SETTING_DCB_FLAG_NONE), "NM_SETTING_DCB_FLAG_NONE", "none" },
    { C_FLAGS(NM_SETTING_DCB_FLAG_ENABLE), "NM_SETTING_DCB_FLAG_ENABLE", "enable" },
    { C_FLAGS(NM_SETTING_DCB_FLAG_ADVERTISE), "NM_SETTING_DCB_FLAG_ADVERTISE", "advertise" },
    { C_FLAGS(NM_SETTING_DCB_FLAG_WILLING), "NM_SETTING_DCB_FLAG_WILLING", "willing" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMSettingDcbFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-setting-ip-config.h" */

GType
nm_ip_address_cmp_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_IP_ADDRESS_CMP_FLAGS_NONE), "NM_IP_ADDRESS_CMP_FLAGS_NONE", "none" },
    { C_FLAGS(NM_IP_ADDRESS_CMP_FLAGS_WITH_ATTRS), "NM_IP_ADDRESS_CMP_FLAGS_WITH_ATTRS", "with-attrs" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMIPAddressCmpFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_ip_routing_rule_as_string_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_IP_ROUTING_RULE_AS_STRING_FLAGS_NONE), "NM_IP_ROUTING_RULE_AS_STRING_FLAGS_NONE", "none" },
    { C_FLAGS(NM_IP_ROUTING_RULE_AS_STRING_FLAGS_AF_INET), "NM_IP_ROUTING_RULE_AS_STRING_FLAGS_AF_INET", "af-inet" },
    { C_FLAGS(NM_IP_ROUTING_RULE_AS_STRING_FLAGS_AF_INET6), "NM_IP_ROUTING_RULE_AS_STRING_FLAGS_AF_INET6", "af-inet6" },
    { C_FLAGS(NM_IP_ROUTING_RULE_AS_STRING_FLAGS_VALIDATE), "NM_IP_ROUTING_RULE_AS_STRING_FLAGS_VALIDATE", "validate" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMIPRoutingRuleAsStringFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_dhcp_hostname_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_DHCP_HOSTNAME_FLAG_NONE), "NM_DHCP_HOSTNAME_FLAG_NONE", "none" },
    { C_FLAGS(NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE), "NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE", "fqdn-serv-update" },
    { C_FLAGS(NM_DHCP_HOSTNAME_FLAG_FQDN_ENCODED), "NM_DHCP_HOSTNAME_FLAG_FQDN_ENCODED", "fqdn-encoded" },
    { C_FLAGS(NM_DHCP_HOSTNAME_FLAG_FQDN_NO_UPDATE), "NM_DHCP_HOSTNAME_FLAG_FQDN_NO_UPDATE", "fqdn-no-update" },
    { C_FLAGS(NM_DHCP_HOSTNAME_FLAG_FQDN_CLEAR_FLAGS), "NM_DHCP_HOSTNAME_FLAG_FQDN_CLEAR_FLAGS", "fqdn-clear-flags" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMDhcpHostnameFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-setting-ip-tunnel.h" */

GType
nm_ip_tunnel_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_IP_TUNNEL_FLAG_NONE), "NM_IP_TUNNEL_FLAG_NONE", "none" },
    { C_FLAGS(NM_IP_TUNNEL_FLAG_IP6_IGN_ENCAP_LIMIT), "NM_IP_TUNNEL_FLAG_IP6_IGN_ENCAP_LIMIT", "ip6-ign-encap-limit" },
    { C_FLAGS(NM_IP_TUNNEL_FLAG_IP6_USE_ORIG_TCLASS), "NM_IP_TUNNEL_FLAG_IP6_USE_ORIG_TCLASS", "ip6-use-orig-tclass" },
    { C_FLAGS(NM_IP_TUNNEL_FLAG_IP6_USE_ORIG_FLOWLABEL), "NM_IP_TUNNEL_FLAG_IP6_USE_ORIG_FLOWLABEL", "ip6-use-orig-flowlabel" },
    { C_FLAGS(NM_IP_TUNNEL_FLAG_IP6_MIP6_DEV), "NM_IP_TUNNEL_FLAG_IP6_MIP6_DEV", "ip6-mip6-dev" },
    { C_FLAGS(NM_IP_TUNNEL_FLAG_IP6_RCV_DSCP_COPY), "NM_IP_TUNNEL_FLAG_IP6_RCV_DSCP_COPY", "ip6-rcv-dscp-copy" },
    { C_FLAGS(NM_IP_TUNNEL_FLAG_IP6_USE_ORIG_FWMARK), "NM_IP_TUNNEL_FLAG_IP6_USE_ORIG_FWMARK", "ip6-use-orig-fwmark" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMIPTunnelFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-setting-ip6-config.h" */

GType
nm_setting_ip6_config_privacy_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_IP6_CONFIG_PRIVACY_UNKNOWN), "NM_SETTING_IP6_CONFIG_PRIVACY_UNKNOWN", "unknown" },
    { C_ENUM(NM_SETTING_IP6_CONFIG_PRIVACY_DISABLED), "NM_SETTING_IP6_CONFIG_PRIVACY_DISABLED", "disabled" },
    { C_ENUM(NM_SETTING_IP6_CONFIG_PRIVACY_PREFER_PUBLIC_ADDR), "NM_SETTING_IP6_CONFIG_PRIVACY_PREFER_PUBLIC_ADDR", "prefer-public-addr" },
    { C_ENUM(NM_SETTING_IP6_CONFIG_PRIVACY_PREFER_TEMP_ADDR), "NM_SETTING_IP6_CONFIG_PRIVACY_PREFER_TEMP_ADDR", "prefer-temp-addr" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSettingIP6ConfigPrivacy"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_setting_ip6_config_addr_gen_mode_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_EUI64), "NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_EUI64", "eui64" },
    { C_ENUM(NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_STABLE_PRIVACY), "NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_STABLE_PRIVACY", "stable-privacy" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSettingIP6ConfigAddrGenMode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-setting-macsec.h" */

GType
nm_setting_macsec_mode_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_MACSEC_MODE_PSK), "NM_SETTING_MACSEC_MODE_PSK", "psk" },
    { C_ENUM(NM_SETTING_MACSEC_MODE_EAP), "NM_SETTING_MACSEC_MODE_EAP", "eap" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSettingMacsecMode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_setting_macsec_validation_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_MACSEC_VALIDATION_DISABLE), "NM_SETTING_MACSEC_VALIDATION_DISABLE", "disable" },
    { C_ENUM(NM_SETTING_MACSEC_VALIDATION_CHECK), "NM_SETTING_MACSEC_VALIDATION_CHECK", "check" },
    { C_ENUM(NM_SETTING_MACSEC_VALIDATION_STRICT), "NM_SETTING_MACSEC_VALIDATION_STRICT", "strict" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSettingMacsecValidation"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-setting-macvlan.h" */

GType
nm_setting_macvlan_mode_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_MACVLAN_MODE_UNKNOWN), "NM_SETTING_MACVLAN_MODE_UNKNOWN", "unknown" },
    { C_ENUM(NM_SETTING_MACVLAN_MODE_VEPA), "NM_SETTING_MACVLAN_MODE_VEPA", "vepa" },
    { C_ENUM(NM_SETTING_MACVLAN_MODE_BRIDGE), "NM_SETTING_MACVLAN_MODE_BRIDGE", "bridge" },
    { C_ENUM(NM_SETTING_MACVLAN_MODE_PRIVATE), "NM_SETTING_MACVLAN_MODE_PRIVATE", "private" },
    { C_ENUM(NM_SETTING_MACVLAN_MODE_PASSTHRU), "NM_SETTING_MACVLAN_MODE_PASSTHRU", "passthru" },
    { C_ENUM(NM_SETTING_MACVLAN_MODE_SOURCE), "NM_SETTING_MACVLAN_MODE_SOURCE", "source" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSettingMacvlanMode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-setting-proxy.h" */

GType
nm_setting_proxy_method_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_PROXY_METHOD_NONE), "NM_SETTING_PROXY_METHOD_NONE", "none" },
    { C_ENUM(NM_SETTING_PROXY_METHOD_AUTO), "NM_SETTING_PROXY_METHOD_AUTO", "auto" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSettingProxyMethod"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-setting-serial.h" */

GType
nm_setting_serial_parity_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_SERIAL_PARITY_NONE), "NM_SETTING_SERIAL_PARITY_NONE", "none" },
    { C_ENUM(NM_SETTING_SERIAL_PARITY_EVEN), "NM_SETTING_SERIAL_PARITY_EVEN", "even" },
    { C_ENUM(NM_SETTING_SERIAL_PARITY_ODD), "NM_SETTING_SERIAL_PARITY_ODD", "odd" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSettingSerialParity"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-setting-sriov.h" */

GType
nm_sriov_vf_vlan_protocol_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SRIOV_VF_VLAN_PROTOCOL_802_1Q), "NM_SRIOV_VF_VLAN_PROTOCOL_802_1Q", "1q" },
    { C_ENUM(NM_SRIOV_VF_VLAN_PROTOCOL_802_1AD), "NM_SRIOV_VF_VLAN_PROTOCOL_802_1AD", "1ad" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSriovVFVlanProtocol"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-setting-team.h" */

GType
nm_team_link_watcher_arp_ping_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_TEAM_LINK_WATCHER_ARP_PING_FLAG_VALIDATE_ACTIVE), "NM_TEAM_LINK_WATCHER_ARP_PING_FLAG_VALIDATE_ACTIVE", "validate-active" },
    { C_FLAGS(NM_TEAM_LINK_WATCHER_ARP_PING_FLAG_VALIDATE_INACTIVE), "NM_TEAM_LINK_WATCHER_ARP_PING_FLAG_VALIDATE_INACTIVE", "validate-inactive" },
    { C_FLAGS(NM_TEAM_LINK_WATCHER_ARP_PING_FLAG_SEND_ALWAYS), "NM_TEAM_LINK_WATCHER_ARP_PING_FLAG_SEND_ALWAYS", "send-always" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMTeamLinkWatcherArpPingFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-setting-tun.h" */

GType
nm_setting_tun_mode_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_TUN_MODE_UNKNOWN), "NM_SETTING_TUN_MODE_UNKNOWN", "unknown" },
    { C_ENUM(NM_SETTING_TUN_MODE_TUN), "NM_SETTING_TUN_MODE_TUN", "tun" },
    { C_ENUM(NM_SETTING_TUN_MODE_TAP), "NM_SETTING_TUN_MODE_TAP", "tap" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSettingTunMode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-setting-vlan.h" */

GType
nm_vlan_priority_map_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_VLAN_INGRESS_MAP), "NM_VLAN_INGRESS_MAP", "ingress-map" },
    { C_ENUM(NM_VLAN_EGRESS_MAP), "NM_VLAN_EGRESS_MAP", "egress-map" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMVlanPriorityMap"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_vlan_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_VLAN_FLAG_REORDER_HEADERS), "NM_VLAN_FLAG_REORDER_HEADERS", "reorder-headers" },
    { C_FLAGS(NM_VLAN_FLAG_GVRP), "NM_VLAN_FLAG_GVRP", "gvrp" },
    { C_FLAGS(NM_VLAN_FLAG_LOOSE_BINDING), "NM_VLAN_FLAG_LOOSE_BINDING", "loose-binding" },
    { C_FLAGS(NM_VLAN_FLAG_MVRP), "NM_VLAN_FLAG_MVRP", "mvrp" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMVlanFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-setting-wired.h" */

GType
nm_setting_wired_wake_on_lan_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_SETTING_WIRED_WAKE_ON_LAN_PHY), "NM_SETTING_WIRED_WAKE_ON_LAN_PHY", "phy" },
    { C_FLAGS(NM_SETTING_WIRED_WAKE_ON_LAN_UNICAST), "NM_SETTING_WIRED_WAKE_ON_LAN_UNICAST", "unicast" },
    { C_FLAGS(NM_SETTING_WIRED_WAKE_ON_LAN_MULTICAST), "NM_SETTING_WIRED_WAKE_ON_LAN_MULTICAST", "multicast" },
    { C_FLAGS(NM_SETTING_WIRED_WAKE_ON_LAN_BROADCAST), "NM_SETTING_WIRED_WAKE_ON_LAN_BROADCAST", "broadcast" },
    { C_FLAGS(NM_SETTING_WIRED_WAKE_ON_LAN_ARP), "NM_SETTING_WIRED_WAKE_ON_LAN_ARP", "arp" },
    { C_FLAGS(NM_SETTING_WIRED_WAKE_ON_LAN_MAGIC), "NM_SETTING_WIRED_WAKE_ON_LAN_MAGIC", "magic" },
    { C_FLAGS(NM_SETTING_WIRED_WAKE_ON_LAN_DEFAULT), "NM_SETTING_WIRED_WAKE_ON_LAN_DEFAULT", "default" },
    { C_FLAGS(NM_SETTING_WIRED_WAKE_ON_LAN_IGNORE), "NM_SETTING_WIRED_WAKE_ON_LAN_IGNORE", "ignore" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMSettingWiredWakeOnLan"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-setting-wireless-security.h" */

GType
nm_wep_key_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_WEP_KEY_TYPE_UNKNOWN), "NM_WEP_KEY_TYPE_UNKNOWN", "unknown" },
    { C_ENUM(NM_WEP_KEY_TYPE_KEY), "NM_WEP_KEY_TYPE_KEY", "key" },
    { C_ENUM(NM_WEP_KEY_TYPE_PASSPHRASE), "NM_WEP_KEY_TYPE_PASSPHRASE", "passphrase" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMWepKeyType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_setting_wireless_security_pmf_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_WIRELESS_SECURITY_PMF_DEFAULT), "NM_SETTING_WIRELESS_SECURITY_PMF_DEFAULT", "default" },
    { C_ENUM(NM_SETTING_WIRELESS_SECURITY_PMF_DISABLE), "NM_SETTING_WIRELESS_SECURITY_PMF_DISABLE", "disable" },
    { C_ENUM(NM_SETTING_WIRELESS_SECURITY_PMF_OPTIONAL), "NM_SETTING_WIRELESS_SECURITY_PMF_OPTIONAL", "optional" },
    { C_ENUM(NM_SETTING_WIRELESS_SECURITY_PMF_REQUIRED), "NM_SETTING_WIRELESS_SECURITY_PMF_REQUIRED", "required" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSettingWirelessSecurityPmf"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_setting_wireless_security_wps_method_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_SETTING_WIRELESS_SECURITY_WPS_METHOD_DEFAULT), "NM_SETTING_WIRELESS_SECURITY_WPS_METHOD_DEFAULT", "default" },
    { C_FLAGS(NM_SETTING_WIRELESS_SECURITY_WPS_METHOD_DISABLED), "NM_SETTING_WIRELESS_SECURITY_WPS_METHOD_DISABLED", "disabled" },
    { C_FLAGS(NM_SETTING_WIRELESS_SECURITY_WPS_METHOD_AUTO), "NM_SETTING_WIRELESS_SECURITY_WPS_METHOD_AUTO", "auto" },
    { C_FLAGS(NM_SETTING_WIRELESS_SECURITY_WPS_METHOD_PBC), "NM_SETTING_WIRELESS_SECURITY_WPS_METHOD_PBC", "pbc" },
    { C_FLAGS(NM_SETTING_WIRELESS_SECURITY_WPS_METHOD_PIN), "NM_SETTING_WIRELESS_SECURITY_WPS_METHOD_PIN", "pin" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMSettingWirelessSecurityWpsMethod"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_setting_wireless_security_fils_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_WIRELESS_SECURITY_FILS_DEFAULT), "NM_SETTING_WIRELESS_SECURITY_FILS_DEFAULT", "default" },
    { C_ENUM(NM_SETTING_WIRELESS_SECURITY_FILS_DISABLE), "NM_SETTING_WIRELESS_SECURITY_FILS_DISABLE", "disable" },
    { C_ENUM(NM_SETTING_WIRELESS_SECURITY_FILS_OPTIONAL), "NM_SETTING_WIRELESS_SECURITY_FILS_OPTIONAL", "optional" },
    { C_ENUM(NM_SETTING_WIRELESS_SECURITY_FILS_REQUIRED), "NM_SETTING_WIRELESS_SECURITY_FILS_REQUIRED", "required" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSettingWirelessSecurityFils"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-setting-wireless.h" */

GType
nm_setting_wireless_wake_on_wlan_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_SETTING_WIRELESS_WAKE_ON_WLAN_ANY), "NM_SETTING_WIRELESS_WAKE_ON_WLAN_ANY", "any" },
    { C_FLAGS(NM_SETTING_WIRELESS_WAKE_ON_WLAN_DISCONNECT), "NM_SETTING_WIRELESS_WAKE_ON_WLAN_DISCONNECT", "disconnect" },
    { C_FLAGS(NM_SETTING_WIRELESS_WAKE_ON_WLAN_MAGIC), "NM_SETTING_WIRELESS_WAKE_ON_WLAN_MAGIC", "magic" },
    { C_FLAGS(NM_SETTING_WIRELESS_WAKE_ON_WLAN_GTK_REKEY_FAILURE), "NM_SETTING_WIRELESS_WAKE_ON_WLAN_GTK_REKEY_FAILURE", "gtk-rekey-failure" },
    { C_FLAGS(NM_SETTING_WIRELESS_WAKE_ON_WLAN_EAP_IDENTITY_REQUEST), "NM_SETTING_WIRELESS_WAKE_ON_WLAN_EAP_IDENTITY_REQUEST", "eap-identity-request" },
    { C_FLAGS(NM_SETTING_WIRELESS_WAKE_ON_WLAN_4WAY_HANDSHAKE), "NM_SETTING_WIRELESS_WAKE_ON_WLAN_4WAY_HANDSHAKE", "4way-handshake" },
    { C_FLAGS(NM_SETTING_WIRELESS_WAKE_ON_WLAN_RFKILL_RELEASE), "NM_SETTING_WIRELESS_WAKE_ON_WLAN_RFKILL_RELEASE", "rfkill-release" },
    { C_FLAGS(NM_SETTING_WIRELESS_WAKE_ON_WLAN_TCP), "NM_SETTING_WIRELESS_WAKE_ON_WLAN_TCP", "tcp" },
    { C_FLAGS(NM_SETTING_WIRELESS_WAKE_ON_WLAN_ALL), "NM_SETTING_WIRELESS_WAKE_ON_WLAN_ALL", "all" },
    { C_FLAGS(NM_SETTING_WIRELESS_WAKE_ON_WLAN_DEFAULT), "NM_SETTING_WIRELESS_WAKE_ON_WLAN_DEFAULT", "default" },
    { C_FLAGS(NM_SETTING_WIRELESS_WAKE_ON_WLAN_IGNORE), "NM_SETTING_WIRELESS_WAKE_ON_WLAN_IGNORE", "ignore" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMSettingWirelessWakeOnWLan"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_setting_wireless_powersave_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_WIRELESS_POWERSAVE_DEFAULT), "NM_SETTING_WIRELESS_POWERSAVE_DEFAULT", "default" },
    { C_ENUM(NM_SETTING_WIRELESS_POWERSAVE_IGNORE), "NM_SETTING_WIRELESS_POWERSAVE_IGNORE", "ignore" },
    { C_ENUM(NM_SETTING_WIRELESS_POWERSAVE_DISABLE), "NM_SETTING_WIRELESS_POWERSAVE_DISABLE", "disable" },
    { C_ENUM(NM_SETTING_WIRELESS_POWERSAVE_ENABLE), "NM_SETTING_WIRELESS_POWERSAVE_ENABLE", "enable" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSettingWirelessPowersave"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-setting.h" */

GType
nm_setting_secret_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_SETTING_SECRET_FLAG_NONE), "NM_SETTING_SECRET_FLAG_NONE", "none" },
    { C_FLAGS(NM_SETTING_SECRET_FLAG_AGENT_OWNED), "NM_SETTING_SECRET_FLAG_AGENT_OWNED", "agent-owned" },
    { C_FLAGS(NM_SETTING_SECRET_FLAG_NOT_SAVED), "NM_SETTING_SECRET_FLAG_NOT_SAVED", "not-saved" },
    { C_FLAGS(NM_SETTING_SECRET_FLAG_NOT_REQUIRED), "NM_SETTING_SECRET_FLAG_NOT_REQUIRED", "not-required" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMSettingSecretFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_setting_compare_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_COMPARE_FLAG_EXACT), "NM_SETTING_COMPARE_FLAG_EXACT", "exact" },
    { C_ENUM(NM_SETTING_COMPARE_FLAG_FUZZY), "NM_SETTING_COMPARE_FLAG_FUZZY", "fuzzy" },
    { C_ENUM(NM_SETTING_COMPARE_FLAG_IGNORE_ID), "NM_SETTING_COMPARE_FLAG_IGNORE_ID", "ignore-id" },
    { C_ENUM(NM_SETTING_COMPARE_FLAG_IGNORE_SECRETS), "NM_SETTING_COMPARE_FLAG_IGNORE_SECRETS", "ignore-secrets" },
    { C_ENUM(NM_SETTING_COMPARE_FLAG_IGNORE_AGENT_OWNED_SECRETS), "NM_SETTING_COMPARE_FLAG_IGNORE_AGENT_OWNED_SECRETS", "ignore-agent-owned-secrets" },
    { C_ENUM(NM_SETTING_COMPARE_FLAG_IGNORE_NOT_SAVED_SECRETS), "NM_SETTING_COMPARE_FLAG_IGNORE_NOT_SAVED_SECRETS", "ignore-not-saved-secrets" },
    { C_ENUM(NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT), "NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT", "diff-result-with-default" },
    { C_ENUM(NM_SETTING_COMPARE_FLAG_DIFF_RESULT_NO_DEFAULT), "NM_SETTING_COMPARE_FLAG_DIFF_RESULT_NO_DEFAULT", "diff-result-no-default" },
    { C_ENUM(NM_SETTING_COMPARE_FLAG_IGNORE_TIMESTAMP), "NM_SETTING_COMPARE_FLAG_IGNORE_TIMESTAMP", "ignore-timestamp" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSettingCompareFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_setting_mac_randomization_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_MAC_RANDOMIZATION_DEFAULT), "NM_SETTING_MAC_RANDOMIZATION_DEFAULT", "default" },
    { C_ENUM(NM_SETTING_MAC_RANDOMIZATION_NEVER), "NM_SETTING_MAC_RANDOMIZATION_NEVER", "never" },
    { C_ENUM(NM_SETTING_MAC_RANDOMIZATION_ALWAYS), "NM_SETTING_MAC_RANDOMIZATION_ALWAYS", "always" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSettingMacRandomization"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_setting_diff_result_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_SETTING_DIFF_RESULT_UNKNOWN), "NM_SETTING_DIFF_RESULT_UNKNOWN", "unknown" },
    { C_ENUM(NM_SETTING_DIFF_RESULT_IN_A), "NM_SETTING_DIFF_RESULT_IN_A", "in-a" },
    { C_ENUM(NM_SETTING_DIFF_RESULT_IN_B), "NM_SETTING_DIFF_RESULT_IN_B", "in-b" },
    { C_ENUM(NM_SETTING_DIFF_RESULT_IN_A_DEFAULT), "NM_SETTING_DIFF_RESULT_IN_A_DEFAULT", "in-a-default" },
    { C_ENUM(NM_SETTING_DIFF_RESULT_IN_B_DEFAULT), "NM_SETTING_DIFF_RESULT_IN_B_DEFAULT", "in-b-default" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMSettingDiffResult"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-utils.h" */

GType
nm_utils_security_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NMU_SEC_INVALID), "NMU_SEC_INVALID", "invalid" },
    { C_ENUM(NMU_SEC_NONE), "NMU_SEC_NONE", "none" },
    { C_ENUM(NMU_SEC_STATIC_WEP), "NMU_SEC_STATIC_WEP", "static-wep" },
    { C_ENUM(NMU_SEC_LEAP), "NMU_SEC_LEAP", "leap" },
    { C_ENUM(NMU_SEC_DYNAMIC_WEP), "NMU_SEC_DYNAMIC_WEP", "dynamic-wep" },
    { C_ENUM(NMU_SEC_WPA_PSK), "NMU_SEC_WPA_PSK", "wpa-psk" },
    { C_ENUM(NMU_SEC_WPA_ENTERPRISE), "NMU_SEC_WPA_ENTERPRISE", "wpa-enterprise" },
    { C_ENUM(NMU_SEC_WPA2_PSK), "NMU_SEC_WPA2_PSK", "wpa2-psk" },
    { C_ENUM(NMU_SEC_WPA2_ENTERPRISE), "NMU_SEC_WPA2_ENTERPRISE", "wpa2-enterprise" },
    { C_ENUM(NMU_SEC_SAE), "NMU_SEC_SAE", "sae" },
    { C_ENUM(NMU_SEC_OWE), "NMU_SEC_OWE", "owe" },
    { C_ENUM(NMU_SEC_WPA3_SUITE_B_192), "NMU_SEC_WPA3_SUITE_B_192", "wpa3-suite-b-192" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMUtilsSecurityType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-vpn-dbus-interface.h" */

GType
nm_vpn_service_state_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_VPN_SERVICE_STATE_UNKNOWN), "NM_VPN_SERVICE_STATE_UNKNOWN", "unknown" },
    { C_ENUM(NM_VPN_SERVICE_STATE_INIT), "NM_VPN_SERVICE_STATE_INIT", "init" },
    { C_ENUM(NM_VPN_SERVICE_STATE_SHUTDOWN), "NM_VPN_SERVICE_STATE_SHUTDOWN", "shutdown" },
    { C_ENUM(NM_VPN_SERVICE_STATE_STARTING), "NM_VPN_SERVICE_STATE_STARTING", "starting" },
    { C_ENUM(NM_VPN_SERVICE_STATE_STARTED), "NM_VPN_SERVICE_STATE_STARTED", "started" },
    { C_ENUM(NM_VPN_SERVICE_STATE_STOPPING), "NM_VPN_SERVICE_STATE_STOPPING", "stopping" },
    { C_ENUM(NM_VPN_SERVICE_STATE_STOPPED), "NM_VPN_SERVICE_STATE_STOPPED", "stopped" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMVpnServiceState"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_vpn_connection_state_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_VPN_CONNECTION_STATE_UNKNOWN), "NM_VPN_CONNECTION_STATE_UNKNOWN", "unknown" },
    { C_ENUM(NM_VPN_CONNECTION_STATE_PREPARE), "NM_VPN_CONNECTION_STATE_PREPARE", "prepare" },
    { C_ENUM(NM_VPN_CONNECTION_STATE_NEED_AUTH), "NM_VPN_CONNECTION_STATE_NEED_AUTH", "need-auth" },
    { C_ENUM(NM_VPN_CONNECTION_STATE_CONNECT), "NM_VPN_CONNECTION_STATE_CONNECT", "connect" },
    { C_ENUM(NM_VPN_CONNECTION_STATE_IP_CONFIG_GET), "NM_VPN_CONNECTION_STATE_IP_CONFIG_GET", "ip-config-get" },
    { C_ENUM(NM_VPN_CONNECTION_STATE_ACTIVATED), "NM_VPN_CONNECTION_STATE_ACTIVATED", "activated" },
    { C_ENUM(NM_VPN_CONNECTION_STATE_FAILED), "NM_VPN_CONNECTION_STATE_FAILED", "failed" },
    { C_ENUM(NM_VPN_CONNECTION_STATE_DISCONNECTED), "NM_VPN_CONNECTION_STATE_DISCONNECTED", "disconnected" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMVpnConnectionState"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_vpn_connection_state_reason_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_VPN_CONNECTION_STATE_REASON_UNKNOWN), "NM_VPN_CONNECTION_STATE_REASON_UNKNOWN", "unknown" },
    { C_ENUM(NM_VPN_CONNECTION_STATE_REASON_NONE), "NM_VPN_CONNECTION_STATE_REASON_NONE", "none" },
    { C_ENUM(NM_VPN_CONNECTION_STATE_REASON_USER_DISCONNECTED), "NM_VPN_CONNECTION_STATE_REASON_USER_DISCONNECTED", "user-disconnected" },
    { C_ENUM(NM_VPN_CONNECTION_STATE_REASON_DEVICE_DISCONNECTED), "NM_VPN_CONNECTION_STATE_REASON_DEVICE_DISCONNECTED", "device-disconnected" },
    { C_ENUM(NM_VPN_CONNECTION_STATE_REASON_SERVICE_STOPPED), "NM_VPN_CONNECTION_STATE_REASON_SERVICE_STOPPED", "service-stopped" },
    { C_ENUM(NM_VPN_CONNECTION_STATE_REASON_IP_CONFIG_INVALID), "NM_VPN_CONNECTION_STATE_REASON_IP_CONFIG_INVALID", "ip-config-invalid" },
    { C_ENUM(NM_VPN_CONNECTION_STATE_REASON_CONNECT_TIMEOUT), "NM_VPN_CONNECTION_STATE_REASON_CONNECT_TIMEOUT", "connect-timeout" },
    { C_ENUM(NM_VPN_CONNECTION_STATE_REASON_SERVICE_START_TIMEOUT), "NM_VPN_CONNECTION_STATE_REASON_SERVICE_START_TIMEOUT", "service-start-timeout" },
    { C_ENUM(NM_VPN_CONNECTION_STATE_REASON_SERVICE_START_FAILED), "NM_VPN_CONNECTION_STATE_REASON_SERVICE_START_FAILED", "service-start-failed" },
    { C_ENUM(NM_VPN_CONNECTION_STATE_REASON_NO_SECRETS), "NM_VPN_CONNECTION_STATE_REASON_NO_SECRETS", "no-secrets" },
    { C_ENUM(NM_VPN_CONNECTION_STATE_REASON_LOGIN_FAILED), "NM_VPN_CONNECTION_STATE_REASON_LOGIN_FAILED", "login-failed" },
    { C_ENUM(NM_VPN_CONNECTION_STATE_REASON_CONNECTION_REMOVED), "NM_VPN_CONNECTION_STATE_REASON_CONNECTION_REMOVED", "connection-removed" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMVpnConnectionStateReason"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
nm_vpn_plugin_failure_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(NM_VPN_PLUGIN_FAILURE_LOGIN_FAILED), "NM_VPN_PLUGIN_FAILURE_LOGIN_FAILED", "login-failed" },
    { C_ENUM(NM_VPN_PLUGIN_FAILURE_CONNECT_FAILED), "NM_VPN_PLUGIN_FAILURE_CONNECT_FAILED", "connect-failed" },
    { C_ENUM(NM_VPN_PLUGIN_FAILURE_BAD_IP_CONFIG), "NM_VPN_PLUGIN_FAILURE_BAD_IP_CONFIG", "bad-ip-config" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("NMVpnPluginFailure"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "nm-vpn-editor-plugin.h" */

GType
nm_vpn_editor_plugin_capability_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(NM_VPN_EDITOR_PLUGIN_CAPABILITY_NONE), "NM_VPN_EDITOR_PLUGIN_CAPABILITY_NONE", "none" },
    { C_FLAGS(NM_VPN_EDITOR_PLUGIN_CAPABILITY_IMPORT), "NM_VPN_EDITOR_PLUGIN_CAPABILITY_IMPORT", "import" },
    { C_FLAGS(NM_VPN_EDITOR_PLUGIN_CAPABILITY_EXPORT), "NM_VPN_EDITOR_PLUGIN_CAPABILITY_EXPORT", "export" },
    { C_FLAGS(NM_VPN_EDITOR_PLUGIN_CAPABILITY_IPV6), "NM_VPN_EDITOR_PLUGIN_CAPABILITY_IPV6", "ipv6" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("NMVpnEditorPluginCapability"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* Generated data ends here */

