Imported Upstream version 0.9.8.10 upstream/0.9.8.10

6 files changed, 278 insertions, 282 deletions

diff --git a/src/generated/Makefile.am b/src/generated/Makefile.am
index 307766e1..b313e454 100644
--- a/src/generated/Makefile.am
+++ b/src/generated/Makefile.am
@@ -50,7 +50,7 @@ GLIB_MKENUMS_C_FLAGS = --identifier-prefix NM
 GLIB_GENERATED += nm-marshal.h nm-marshal.c
 nm_marshal_sources = $(nm_daemon_sources)
 
-INCLUDES = \
+libnm_generated_la_CPPFLAGS = \
 	-I${top_srcdir}/include \
 	-I${top_builddir}/include \
 	-I${top_srcdir}/src \
@@ -67,13 +67,7 @@ INCLUDES = \
 	-I$(top_srcdir)/src/firewall-manager \
 	-I$(top_srcdir)/src/settings \
 	-I$(top_srcdir)/src/wifi \
-	-I$(top_srcdir)/libnm-util
-
-if WITH_WIMAX
-INCLUDES += -I$(top_srcdir)/src/wimax
-endif
-
-libnm_generated_la_CPPFLAGS = \
+	-I$(top_srcdir)/libnm-util \
 	$(DBUS_CFLAGS) \
 	$(GLIB_CFLAGS) \
 	$(GUDEV_CFLAGS) \
@@ -82,8 +76,12 @@ libnm_generated_la_CPPFLAGS = \
 	$(SYSTEMD_LOGIN_CFLAGS) \
 	$(IWMX_SDK_CFLAGS)
 
+if WITH_WIMAX
+libnm_generated_la_CPPFLAGS += -I$(top_srcdir)/src/wimax
+endif
+
 if WITH_MODEM_MANAGER_1
-	libnm_generated_la_CPPFLAGS += $(MM_GLIB_CFLAGS)
+libnm_generated_la_CPPFLAGS += $(MM_GLIB_CFLAGS)
 endif
 
 libnm_generated_la_LIBADD = \
diff --git a/src/generated/Makefile.in b/src/generated/Makefile.in
index ba64a615..350bf7f7 100644
--- a/src/generated/Makefile.in
+++ b/src/generated/Makefile.in
@@ -80,6 +80,7 @@ build_triplet = @build@
 host_triplet = @host@
 @WITH_WIMAX_TRUE@am__append_1 = $(top_srcdir)/src/wimax/*.[ch]
 @WITH_WIMAX_TRUE@am__append_2 = -I$(top_srcdir)/src/wimax
+@WITH_MODEM_MANAGER_1_TRUE@am__append_3 = $(MM_GLIB_CFLAGS)
 subdir = src/generated
 DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
 	$(top_srcdir)/build-aux/depcomp
@@ -205,6 +206,7 @@ DEPDIR = @DEPDIR@
 DHCLIENT_PATH = @DHCLIENT_PATH@
 DHCPCD_PATH = @DHCPCD_PATH@
 DLLTOOL = @DLLTOOL@
+DNSMASQ_PATH = @DNSMASQ_PATH@
 DSYMUTIL = @DSYMUTIL@
 DUMPBIN = @DUMPBIN@
 ECHO_C = @ECHO_C@
@@ -227,6 +229,7 @@ GNUTLS_CFLAGS = @GNUTLS_CFLAGS@
 GNUTLS_LIBS = @GNUTLS_LIBS@
 GREP = @GREP@
 GTKDOC_CHECK = @GTKDOC_CHECK@
+GTKDOC_CHECK_PATH = @GTKDOC_CHECK_PATH@
 GTKDOC_DEPS_CFLAGS = @GTKDOC_DEPS_CFLAGS@
 GTKDOC_DEPS_LIBS = @GTKDOC_DEPS_LIBS@
 GTKDOC_MKPDF = @GTKDOC_MKPDF@
@@ -451,9 +454,9 @@ nm_enum_types_sources = $(nm_daemon_sources)
 GLIB_MKENUMS_H_FLAGS = --identifier-prefix NM
 GLIB_MKENUMS_C_FLAGS = --identifier-prefix NM
 nm_marshal_sources = $(nm_daemon_sources)
-INCLUDES = -I${top_srcdir}/include -I${top_builddir}/include \
-	-I${top_srcdir}/src -I${top_srcdir}/src/logging \
-	-I${top_srcdir}/src/dns-manager \
+libnm_generated_la_CPPFLAGS = -I${top_srcdir}/include \
+	-I${top_builddir}/include -I${top_srcdir}/src \
+	-I${top_srcdir}/src/logging -I${top_srcdir}/src/dns-manager \
 	-I${top_srcdir}/src/vpn-manager \
 	-I${top_srcdir}/src/dhcp-manager \
 	-I${top_srcdir}/src/ip6-manager \
@@ -464,16 +467,10 @@ INCLUDES = -I${top_srcdir}/include -I${top_builddir}/include \
 	-I$(top_srcdir)/src/bluez-manager \
 	-I$(top_srcdir)/src/firewall-manager \
 	-I$(top_srcdir)/src/settings -I$(top_srcdir)/src/wifi \
-	-I$(top_srcdir)/libnm-util $(am__append_2)
-libnm_generated_la_CPPFLAGS = \
-	$(DBUS_CFLAGS) \
-	$(GLIB_CFLAGS) \
-	$(GUDEV_CFLAGS) \
-	$(LIBNL_CFLAGS) \
-	$(POLKIT_CFLAGS) \
-	$(SYSTEMD_LOGIN_CFLAGS) \
-	$(IWMX_SDK_CFLAGS)
-
+	-I$(top_srcdir)/libnm-util $(DBUS_CFLAGS) $(GLIB_CFLAGS) \
+	$(GUDEV_CFLAGS) $(LIBNL_CFLAGS) $(POLKIT_CFLAGS) \
+	$(SYSTEMD_LOGIN_CFLAGS) $(IWMX_SDK_CFLAGS) $(am__append_2) \
+	$(am__append_3)
 libnm_generated_la_LIBADD = \
 	$(GLIB_LIBS)
 
@@ -786,8 +783,6 @@ uninstall-am:
 
 include $(GLIB_MAKEFILE)
 
-@WITH_MODEM_MANAGER_1_TRUE@	libnm_generated_la_CPPFLAGS += $(MM_GLIB_CFLAGS)
-
 # Tell versions [3.59,3.63) of GNU make to not export all variables.
 # Otherwise a system limit (for SysV at least) may be exceeded.
 .NOEXPORT:
diff --git a/src/generated/nm-enum-types.c b/src/generated/nm-enum-types.c
index 78fdee46..9bb95806 100644
--- a/src/generated/nm-enum-types.c
+++ b/src/generated/nm-enum-types.c
@@ -5,52 +5,52 @@
 
 #include "nm-enum-types.h"
 
-#include "nm-manager.h" 
-#include "nm-types.h" 
-#include "nm-system.h" 
-#include "nm-hostname-provider.h" 
-#include "nm-manager-auth.h" 
-#include "nm-netlink-utils.h" 
-#include "nm-netlink-monitor.h" 
-#include "nm-connectivity.h" 
-#include "nm-device-vlan.h" 
-#include "nm-ip4-config.h" 
-#include "nm-sleep-monitor.h" 
-#include "nm-device.h" 
-#include "nm-device-olpc-mesh.h" 
-#include "nm-device-bridge.h" 
-#include "nm-device-private.h" 
-#include "nm-dhcp6-config.h" 
-#include "nm-ip6-config.h" 
-#include "nm-device-bond.h" 
-#include "nm-wifi-ap-utils.h" 
-#include "nm-device-adsl.h" 
-#include "nm-policy.h" 
-#include "nm-device-modem.h" 
-#include "nm-activation-request.h" 
-#include "nm-policy-hostname.h" 
-#include "nm-properties-changed-signal.h" 
-#include "nm-wifi-ap.h" 
-#include "nm-config.h" 
-#include "nm-device-wired.h" 
-#include "nm-rfkill.h" 
-#include "NetworkManagerUtils.h" 
-#include "nm-device-factory.h" 
 #include "nm-active-connection.h" 
+#include "nm-wifi-ap.h" 
 #include "nm-device-bt.h" 
 #include "nm-device-infiniband.h" 
-#include "nm-device-wifi.h" 
-#include "nm-dbus-manager.h" 
-#include "nm-dhcp4-config.h" 
+#include "nm-device-bond.h" 
+#include "nm-device-wired.h" 
+#include "nm-dhcp6-config.h" 
 #include "nm-session-utils.h" 
 #include "nm-netlink-compat.h" 
 #include "nm-session-monitor.h" 
 #include "nm-connection-provider.h" 
 #include "nm-device-ethernet.h" 
 #include "nm-call-store.h" 
+#include "nm-config.h" 
 #include "nm-policy-hosts.h" 
+#include "nm-rfkill.h" 
 #include "nm-dispatcher.h" 
+#include "nm-ip4-config.h" 
+#include "nm-manager.h" 
+#include "nm-device-modem.h" 
+#include "nm-activation-request.h" 
+#include "nm-wifi-ap-utils.h" 
+#include "nm-dbus-manager.h" 
+#include "nm-policy-hostname.h" 
+#include "nm-device.h" 
+#include "nm-types.h" 
+#include "nm-ip6-config.h" 
+#include "nm-system.h" 
+#include "nm-policy.h" 
+#include "nm-manager-auth.h" 
+#include "nm-device-bridge.h" 
+#include "nm-device-wifi.h" 
+#include "nm-device-private.h" 
+#include "nm-netlink-utils.h" 
+#include "nm-dhcp4-config.h" 
 #include "nm-udev-manager.h" 
+#include "nm-connectivity.h" 
+#include "nm-device-vlan.h" 
+#include "nm-netlink-monitor.h" 
+#include "nm-device-olpc-mesh.h" 
+#include "nm-hostname-provider.h" 
+#include "nm-sleep-monitor.h" 
+#include "nm-device-factory.h" 
+#include "NetworkManagerUtils.h" 
+#include "nm-device-adsl.h" 
+#include "nm-properties-changed-signal.h" 
 #include "nm-logging.h" 
 #include "nm-dns-utils.h" 
 #include "nm-dns-plugin.h" 
@@ -86,10 +86,10 @@
 #include "nm-bluez4-adapter.h" 
 #include "nm-firewall-manager.h" 
 #include "nm-settings-connection.h" 
+#include "nm-settings.h" 
 #include "nm-default-wired-connection.h" 
 #include "nm-system-config-interface.h" 
 #include "nm-settings-utils.h" 
-#include "nm-settings.h" 
 #include "nm-settings-error.h" 
 #include "nm-agent-manager.h" 
 #include "nm-inotify-helper.h" 
@@ -101,464 +101,464 @@
 #include "nm-wimax-nsp.h"
 
 GType
-nm_manager_error_get_type (void)
+nm_bt_error_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { NM_MANAGER_ERROR_UNKNOWN_CONNECTION, "NM_MANAGER_ERROR_UNKNOWN_CONNECTION", "UnknownConnection" },
-        { NM_MANAGER_ERROR_UNKNOWN_DEVICE, "NM_MANAGER_ERROR_UNKNOWN_DEVICE", "UnknownDevice" },
-        { NM_MANAGER_ERROR_UNMANAGED_DEVICE, "NM_MANAGER_ERROR_UNMANAGED_DEVICE", "UnmanagedDevice" },
-        { NM_MANAGER_ERROR_SYSTEM_CONNECTION, "NM_MANAGER_ERROR_SYSTEM_CONNECTION", "SystemConnection" },
-        { NM_MANAGER_ERROR_PERMISSION_DENIED, "NM_MANAGER_ERROR_PERMISSION_DENIED", "PermissionDenied" },
-        { NM_MANAGER_ERROR_CONNECTION_NOT_ACTIVE, "NM_MANAGER_ERROR_CONNECTION_NOT_ACTIVE", "ConnectionNotActive" },
-        { NM_MANAGER_ERROR_ALREADY_ASLEEP_OR_AWAKE, "NM_MANAGER_ERROR_ALREADY_ASLEEP_OR_AWAKE", "AlreadyAsleepOrAwake" },
-        { NM_MANAGER_ERROR_ALREADY_ENABLED_OR_DISABLED, "NM_MANAGER_ERROR_ALREADY_ENABLED_OR_DISABLED", "AlreadyEnabledOrDisabled" },
-        { NM_MANAGER_ERROR_UNSUPPORTED_CONNECTION_TYPE, "NM_MANAGER_ERROR_UNSUPPORTED_CONNECTION_TYPE", "UnsupportedConnectionType" },
-        { NM_MANAGER_ERROR_DEPENDENCY_FAILED, "NM_MANAGER_ERROR_DEPENDENCY_FAILED", "DependencyFailed" },
-        { NM_MANAGER_ERROR_AUTOCONNECT_NOT_ALLOWED, "NM_MANAGER_ERROR_AUTOCONNECT_NOT_ALLOWED", "AutoconnectNotAllowed" },
+        { NM_BT_ERROR_CONNECTION_NOT_BT, "NM_BT_ERROR_CONNECTION_NOT_BT", "ConnectionNotBt" },
+        { NM_BT_ERROR_CONNECTION_INVALID, "NM_BT_ERROR_CONNECTION_INVALID", "ConnectionInvalid" },
+        { NM_BT_ERROR_CONNECTION_INCOMPATIBLE, "NM_BT_ERROR_CONNECTION_INCOMPATIBLE", "ConnectionIncompatible" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("NMManagerError"), values);
+        g_enum_register_static (g_intern_static_string ("NMBtError"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
   return g_define_type_id__volatile;
 }
 GType
-nm_auth_call_result_get_type (void)
+nm_infiniband_error_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { NM_AUTH_CALL_RESULT_UNKNOWN, "NM_AUTH_CALL_RESULT_UNKNOWN", "unknown" },
-        { NM_AUTH_CALL_RESULT_YES, "NM_AUTH_CALL_RESULT_YES", "yes" },
-        { NM_AUTH_CALL_RESULT_AUTH, "NM_AUTH_CALL_RESULT_AUTH", "auth" },
-        { NM_AUTH_CALL_RESULT_NO, "NM_AUTH_CALL_RESULT_NO", "no" },
+        { NM_INFINIBAND_ERROR_CONNECTION_NOT_INFINIBAND, "NM_INFINIBAND_ERROR_CONNECTION_NOT_INFINIBAND", "ConnectionNotInfiniband" },
+        { NM_INFINIBAND_ERROR_CONNECTION_INVALID, "NM_INFINIBAND_ERROR_CONNECTION_INVALID", "ConnectionInvalid" },
+        { NM_INFINIBAND_ERROR_CONNECTION_INCOMPATIBLE, "NM_INFINIBAND_ERROR_CONNECTION_INCOMPATIBLE", "ConnectionIncompatible" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("NMAuthCallResult"), values);
+        g_enum_register_static (g_intern_static_string ("NMInfinibandError"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
   return g_define_type_id__volatile;
 }
 GType
-nm_nm_nl_prop_get_type (void)
+nm_bond_error_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { NMNL_PROP_INVALID, "NMNL_PROP_INVALID", "invalid" },
-        { NMNL_PROP_PROT, "NMNL_PROP_PROT", "prot" },
-        { NMNL_PROP_SCOPE, "NMNL_PROP_SCOPE", "scope" },
-        { NMNL_PROP_TABLE, "NMNL_PROP_TABLE", "table" },
-        { NMNL_PROP_PRIO, "NMNL_PROP_PRIO", "prio" },
+        { NM_BOND_ERROR_CONNECTION_NOT_BOND, "NM_BOND_ERROR_CONNECTION_NOT_BOND", "ConnectionNotBond" },
+        { NM_BOND_ERROR_CONNECTION_INVALID, "NM_BOND_ERROR_CONNECTION_INVALID", "ConnectionInvalid" },
+        { NM_BOND_ERROR_CONNECTION_INCOMPATIBLE, "NM_BOND_ERROR_CONNECTION_INCOMPATIBLE", "ConnectionIncompatible" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("NmNlProp"), values);
+        g_enum_register_static (g_intern_static_string ("NMBondError"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
   return g_define_type_id__volatile;
 }
 GType
-nm_netlink_monitor_error_get_type (void)
+nm_session_monitor_error_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { NM_NETLINK_MONITOR_ERROR_GENERIC, "NM_NETLINK_MONITOR_ERROR_GENERIC", "generic" },
-        { NM_NETLINK_MONITOR_ERROR_NETLINK_ALLOC_HANDLE, "NM_NETLINK_MONITOR_ERROR_NETLINK_ALLOC_HANDLE", "netlink-alloc-handle" },
-        { NM_NETLINK_MONITOR_ERROR_NETLINK_CONNECT, "NM_NETLINK_MONITOR_ERROR_NETLINK_CONNECT", "netlink-connect" },
-        { NM_NETLINK_MONITOR_ERROR_NETLINK_JOIN_GROUP, "NM_NETLINK_MONITOR_ERROR_NETLINK_JOIN_GROUP", "netlink-join-group" },
-        { NM_NETLINK_MONITOR_ERROR_NETLINK_ALLOC_LINK_CACHE, "NM_NETLINK_MONITOR_ERROR_NETLINK_ALLOC_LINK_CACHE", "netlink-alloc-link-cache" },
-        { NM_NETLINK_MONITOR_ERROR_PROCESSING_MESSAGE, "NM_NETLINK_MONITOR_ERROR_PROCESSING_MESSAGE", "processing-message" },
-        { NM_NETLINK_MONITOR_ERROR_BAD_ALLOC, "NM_NETLINK_MONITOR_ERROR_BAD_ALLOC", "bad-alloc" },
-        { NM_NETLINK_MONITOR_ERROR_WAITING_FOR_SOCKET_DATA, "NM_NETLINK_MONITOR_ERROR_WAITING_FOR_SOCKET_DATA", "waiting-for-socket-data" },
-        { NM_NETLINK_MONITOR_ERROR_LINK_CACHE_UPDATE, "NM_NETLINK_MONITOR_ERROR_LINK_CACHE_UPDATE", "link-cache-update" },
+        { NM_SESSION_MONITOR_ERROR_IO_ERROR, "NM_SESSION_MONITOR_ERROR_IO_ERROR", "IOError" },
+        { NM_SESSION_MONITOR_ERROR_MALFORMED_DATABASE, "NM_SESSION_MONITOR_ERROR_MALFORMED_DATABASE", "MalformedDatabase" },
+        { NM_SESSION_MONITOR_ERROR_UNKNOWN_USER, "NM_SESSION_MONITOR_ERROR_UNKNOWN_USER", "UnknownUser" },
+        { NM_SESSION_MONITOR_ERROR_NO_DATABASE, "NM_SESSION_MONITOR_ERROR_NO_DATABASE", "NoDatabase" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("NMNetlinkMonitorError"), values);
+        g_enum_register_static (g_intern_static_string ("NMSessionMonitorError"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
   return g_define_type_id__volatile;
 }
 GType
-nm_vlan_error_get_type (void)
+nm_ethernet_error_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { NM_VLAN_ERROR_CONNECTION_NOT_VLAN, "NM_VLAN_ERROR_CONNECTION_NOT_VLAN", "ConnectionNotVlan" },
-        { NM_VLAN_ERROR_CONNECTION_INVALID, "NM_VLAN_ERROR_CONNECTION_INVALID", "ConnectionInvalid" },
-        { NM_VLAN_ERROR_CONNECTION_INCOMPATIBLE, "NM_VLAN_ERROR_CONNECTION_INCOMPATIBLE", "ConnectionIncompatible" },
+        { NM_ETHERNET_ERROR_CONNECTION_NOT_WIRED, "NM_ETHERNET_ERROR_CONNECTION_NOT_WIRED", "ConnectionNotWired" },
+        { NM_ETHERNET_ERROR_CONNECTION_INVALID, "NM_ETHERNET_ERROR_CONNECTION_INVALID", "ConnectionInvalid" },
+        { NM_ETHERNET_ERROR_CONNECTION_INCOMPATIBLE, "NM_ETHERNET_ERROR_CONNECTION_INCOMPATIBLE", "ConnectionIncompatible" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("NMVlanError"), values);
+        g_enum_register_static (g_intern_static_string ("NMEthernetError"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
   return g_define_type_id__volatile;
 }
 GType
-nm_ip4_config_compare_flags_get_type (void)
+nm_config_error_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { NM_IP4_COMPARE_FLAG_NONE, "NM_IP4_COMPARE_FLAG_NONE", "none" },
-        { NM_IP4_COMPARE_FLAG_ADDRESSES, "NM_IP4_COMPARE_FLAG_ADDRESSES", "addresses" },
-        { NM_IP4_COMPARE_FLAG_PTP_ADDRESS, "NM_IP4_COMPARE_FLAG_PTP_ADDRESS", "ptp-address" },
-        { NM_IP4_COMPARE_FLAG_NAMESERVERS, "NM_IP4_COMPARE_FLAG_NAMESERVERS", "nameservers" },
-        { NM_IP4_COMPARE_FLAG_ROUTES, "NM_IP4_COMPARE_FLAG_ROUTES", "routes" },
-        { NM_IP4_COMPARE_FLAG_DOMAINS, "NM_IP4_COMPARE_FLAG_DOMAINS", "domains" },
-        { NM_IP4_COMPARE_FLAG_SEARCHES, "NM_IP4_COMPARE_FLAG_SEARCHES", "searches" },
-        { NM_IP4_COMPARE_FLAG_MTU, "NM_IP4_COMPARE_FLAG_MTU", "mtu" },
-        { NM_IP4_COMPARE_FLAG_MSS, "NM_IP4_COMPARE_FLAG_MSS", "mss" },
-        { NM_IP4_COMPARE_FLAG_WINS_SERVERS, "NM_IP4_COMPARE_FLAG_WINS_SERVERS", "wins-servers" },
-        { NM_IP4_COMPARE_FLAG_NIS_SERVERS, "NM_IP4_COMPARE_FLAG_NIS_SERVERS", "nis-servers" },
-        { NM_IP4_COMPARE_FLAG_NIS_DOMAIN, "NM_IP4_COMPARE_FLAG_NIS_DOMAIN", "nis-domain" },
-        { NM_IP4_COMPARE_FLAG_ALL, "NM_IP4_COMPARE_FLAG_ALL", "all" },
+        { NM_CONFIG_ERROR_NO_MEMORY, "NM_CONFIG_ERROR_NO_MEMORY", "NoMemory" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("NMIP4ConfigCompareFlags"), values);
+        g_enum_register_static (g_intern_static_string ("NMConfigError"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
   return g_define_type_id__volatile;
 }
 GType
-nm_device_error_get_type (void)
+nm_rf_kill_state_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { NM_DEVICE_ERROR_CONNECTION_ACTIVATING, "NM_DEVICE_ERROR_CONNECTION_ACTIVATING", "ConnectionActivating" },
-        { NM_DEVICE_ERROR_CONNECTION_INVALID, "NM_DEVICE_ERROR_CONNECTION_INVALID", "ConnectionInvalid" },
-        { NM_DEVICE_ERROR_NOT_ACTIVE, "NM_DEVICE_ERROR_NOT_ACTIVE", "NotActive" },
+        { RFKILL_UNBLOCKED, "RFKILL_UNBLOCKED", "unblocked" },
+        { RFKILL_SOFT_BLOCKED, "RFKILL_SOFT_BLOCKED", "soft-blocked" },
+        { RFKILL_HARD_BLOCKED, "RFKILL_HARD_BLOCKED", "hard-blocked" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("NMDeviceError"), values);
+        g_enum_register_static (g_intern_static_string ("RfKillState"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
   return g_define_type_id__volatile;
 }
 GType
-nm_olpc_mesh_error_get_type (void)
+nm_rf_kill_type_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { NM_OLPC_MESH_ERROR_CONNECTION_NOT_MESH, "NM_OLPC_MESH_ERROR_CONNECTION_NOT_MESH", "ConnectionNotMesh" },
-        { NM_OLPC_MESH_ERROR_CONNECTION_INVALID, "NM_OLPC_MESH_ERROR_CONNECTION_INVALID", "ConnectionInvalid" },
-        { NM_OLPC_MESH_ERROR_CONNECTION_INCOMPATIBLE, "NM_OLPC_MESH_ERROR_CONNECTION_INCOMPATIBLE", "ConnectionIncompatible" },
+        { RFKILL_TYPE_WLAN, "RFKILL_TYPE_WLAN", "wlan" },
+        { RFKILL_TYPE_WWAN, "RFKILL_TYPE_WWAN", "wwan" },
+        { RFKILL_TYPE_WIMAX, "RFKILL_TYPE_WIMAX", "wimax" },
+        { RFKILL_TYPE_UNKNOWN, "RFKILL_TYPE_UNKNOWN", "unknown" },
+        { RFKILL_TYPE_MAX, "RFKILL_TYPE_MAX", "max" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("NMOlpcMeshError"), values);
+        g_enum_register_static (g_intern_static_string ("RfKillType"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
   return g_define_type_id__volatile;
 }
 GType
-nm_bridge_error_get_type (void)
+nm_dispatcher_action_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { NM_BRIDGE_ERROR_CONNECTION_NOT_BRIDGE, "NM_BRIDGE_ERROR_CONNECTION_NOT_BRIDGE", "ConnectionNotBridge" },
-        { NM_BRIDGE_ERROR_CONNECTION_INVALID, "NM_BRIDGE_ERROR_CONNECTION_INVALID", "ConnectionInvalid" },
-        { NM_BRIDGE_ERROR_CONNECTION_INCOMPATIBLE, "NM_BRIDGE_ERROR_CONNECTION_INCOMPATIBLE", "ConnectionIncompatible" },
+        { DISPATCHER_ACTION_HOSTNAME, "DISPATCHER_ACTION_HOSTNAME", "hostname" },
+        { DISPATCHER_ACTION_UP, "DISPATCHER_ACTION_UP", "up" },
+        { DISPATCHER_ACTION_PRE_DOWN, "DISPATCHER_ACTION_PRE_DOWN", "pre-down" },
+        { DISPATCHER_ACTION_DOWN, "DISPATCHER_ACTION_DOWN", "down" },
+        { DISPATCHER_ACTION_VPN_UP, "DISPATCHER_ACTION_VPN_UP", "vpn-up" },
+        { DISPATCHER_ACTION_VPN_PRE_DOWN, "DISPATCHER_ACTION_VPN_PRE_DOWN", "vpn-pre-down" },
+        { DISPATCHER_ACTION_VPN_DOWN, "DISPATCHER_ACTION_VPN_DOWN", "vpn-down" },
+        { DISPATCHER_ACTION_DHCP4_CHANGE, "DISPATCHER_ACTION_DHCP4_CHANGE", "dhcp4-change" },
+        { DISPATCHER_ACTION_DHCP6_CHANGE, "DISPATCHER_ACTION_DHCP6_CHANGE", "dhcp6-change" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("NMBridgeError"), values);
+        g_enum_register_static (g_intern_static_string ("DispatcherAction"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
   return g_define_type_id__volatile;
 }
 GType
-nm_ip6_config_compare_flags_get_type (void)
+nm_ip4_config_compare_flags_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { NM_IP6_COMPARE_FLAG_NONE, "NM_IP6_COMPARE_FLAG_NONE", "none" },
-        { NM_IP6_COMPARE_FLAG_ADDRESSES, "NM_IP6_COMPARE_FLAG_ADDRESSES", "addresses" },
-        { NM_IP6_COMPARE_FLAG_PTP_ADDRESS, "NM_IP6_COMPARE_FLAG_PTP_ADDRESS", "ptp-address" },
-        { NM_IP6_COMPARE_FLAG_NAMESERVERS, "NM_IP6_COMPARE_FLAG_NAMESERVERS", "nameservers" },
-        { NM_IP6_COMPARE_FLAG_ROUTES, "NM_IP6_COMPARE_FLAG_ROUTES", "routes" },
-        { NM_IP6_COMPARE_FLAG_DOMAINS, "NM_IP6_COMPARE_FLAG_DOMAINS", "domains" },
-        { NM_IP6_COMPARE_FLAG_SEARCHES, "NM_IP6_COMPARE_FLAG_SEARCHES", "searches" },
-        { NM_IP6_COMPARE_FLAG_MSS, "NM_IP6_COMPARE_FLAG_MSS", "mss" },
-        { NM_IP6_COMPARE_FLAG_ALL, "NM_IP6_COMPARE_FLAG_ALL", "all" },
+        { NM_IP4_COMPARE_FLAG_NONE, "NM_IP4_COMPARE_FLAG_NONE", "none" },
+        { NM_IP4_COMPARE_FLAG_ADDRESSES, "NM_IP4_COMPARE_FLAG_ADDRESSES", "addresses" },
+        { NM_IP4_COMPARE_FLAG_PTP_ADDRESS, "NM_IP4_COMPARE_FLAG_PTP_ADDRESS", "ptp-address" },
+        { NM_IP4_COMPARE_FLAG_NAMESERVERS, "NM_IP4_COMPARE_FLAG_NAMESERVERS", "nameservers" },
+        { NM_IP4_COMPARE_FLAG_ROUTES, "NM_IP4_COMPARE_FLAG_ROUTES", "routes" },
+        { NM_IP4_COMPARE_FLAG_DOMAINS, "NM_IP4_COMPARE_FLAG_DOMAINS", "domains" },
+        { NM_IP4_COMPARE_FLAG_SEARCHES, "NM_IP4_COMPARE_FLAG_SEARCHES", "searches" },
+        { NM_IP4_COMPARE_FLAG_MTU, "NM_IP4_COMPARE_FLAG_MTU", "mtu" },
+        { NM_IP4_COMPARE_FLAG_MSS, "NM_IP4_COMPARE_FLAG_MSS", "mss" },
+        { NM_IP4_COMPARE_FLAG_WINS_SERVERS, "NM_IP4_COMPARE_FLAG_WINS_SERVERS", "wins-servers" },
+        { NM_IP4_COMPARE_FLAG_NIS_SERVERS, "NM_IP4_COMPARE_FLAG_NIS_SERVERS", "nis-servers" },
+        { NM_IP4_COMPARE_FLAG_NIS_DOMAIN, "NM_IP4_COMPARE_FLAG_NIS_DOMAIN", "nis-domain" },
+        { NM_IP4_COMPARE_FLAG_ALL, "NM_IP4_COMPARE_FLAG_ALL", "all" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("NMIP6ConfigCompareFlags"), values);
+        g_enum_register_static (g_intern_static_string ("NMIP4ConfigCompareFlags"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
   return g_define_type_id__volatile;
 }
 GType
-nm_bond_error_get_type (void)
+nm_manager_error_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { NM_BOND_ERROR_CONNECTION_NOT_BOND, "NM_BOND_ERROR_CONNECTION_NOT_BOND", "ConnectionNotBond" },
-        { NM_BOND_ERROR_CONNECTION_INVALID, "NM_BOND_ERROR_CONNECTION_INVALID", "ConnectionInvalid" },
-        { NM_BOND_ERROR_CONNECTION_INCOMPATIBLE, "NM_BOND_ERROR_CONNECTION_INCOMPATIBLE", "ConnectionIncompatible" },
+        { NM_MANAGER_ERROR_UNKNOWN_CONNECTION, "NM_MANAGER_ERROR_UNKNOWN_CONNECTION", "UnknownConnection" },
+        { NM_MANAGER_ERROR_UNKNOWN_DEVICE, "NM_MANAGER_ERROR_UNKNOWN_DEVICE", "UnknownDevice" },
+        { NM_MANAGER_ERROR_UNMANAGED_DEVICE, "NM_MANAGER_ERROR_UNMANAGED_DEVICE", "UnmanagedDevice" },
+        { NM_MANAGER_ERROR_SYSTEM_CONNECTION, "NM_MANAGER_ERROR_SYSTEM_CONNECTION", "SystemConnection" },
+        { NM_MANAGER_ERROR_PERMISSION_DENIED, "NM_MANAGER_ERROR_PERMISSION_DENIED", "PermissionDenied" },
+        { NM_MANAGER_ERROR_CONNECTION_NOT_ACTIVE, "NM_MANAGER_ERROR_CONNECTION_NOT_ACTIVE", "ConnectionNotActive" },
+        { NM_MANAGER_ERROR_ALREADY_ASLEEP_OR_AWAKE, "NM_MANAGER_ERROR_ALREADY_ASLEEP_OR_AWAKE", "AlreadyAsleepOrAwake" },
+        { NM_MANAGER_ERROR_ALREADY_ENABLED_OR_DISABLED, "NM_MANAGER_ERROR_ALREADY_ENABLED_OR_DISABLED", "AlreadyEnabledOrDisabled" },
+        { NM_MANAGER_ERROR_UNSUPPORTED_CONNECTION_TYPE, "NM_MANAGER_ERROR_UNSUPPORTED_CONNECTION_TYPE", "UnsupportedConnectionType" },
+        { NM_MANAGER_ERROR_DEPENDENCY_FAILED, "NM_MANAGER_ERROR_DEPENDENCY_FAILED", "DependencyFailed" },
+        { NM_MANAGER_ERROR_AUTOCONNECT_NOT_ALLOWED, "NM_MANAGER_ERROR_AUTOCONNECT_NOT_ALLOWED", "AutoconnectNotAllowed" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("NMBondError"), values);
+        g_enum_register_static (g_intern_static_string ("NMManagerError"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
   return g_define_type_id__volatile;
 }
 GType
-nm_adsl_error_get_type (void)
+nm_device_error_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { NM_ADSL_ERROR_CONNECTION_NOT_ADSL, "NM_ADSL_ERROR_CONNECTION_NOT_ADSL", "ConnectionNotAdsl" },
-        { NM_ADSL_ERROR_CONNECTION_INVALID, "NM_ADSL_ERROR_CONNECTION_INVALID", "ConnectionInvalid" },
-        { NM_ADSL_ERROR_CONNECTION_INCOMPATIBLE, "NM_ADSL_ERROR_CONNECTION_INCOMPATIBLE", "ConnectionIncompatible" },
+        { NM_DEVICE_ERROR_CONNECTION_ACTIVATING, "NM_DEVICE_ERROR_CONNECTION_ACTIVATING", "ConnectionActivating" },
+        { NM_DEVICE_ERROR_CONNECTION_INVALID, "NM_DEVICE_ERROR_CONNECTION_INVALID", "ConnectionInvalid" },
+        { NM_DEVICE_ERROR_NOT_ACTIVE, "NM_DEVICE_ERROR_NOT_ACTIVE", "NotActive" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("NMAdslError"), values);
+        g_enum_register_static (g_intern_static_string ("NMDeviceError"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
   return g_define_type_id__volatile;
 }
 GType
-nm_config_error_get_type (void)
+nm_ip6_config_compare_flags_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { NM_CONFIG_ERROR_NO_MEMORY, "NM_CONFIG_ERROR_NO_MEMORY", "NoMemory" },
+        { NM_IP6_COMPARE_FLAG_NONE, "NM_IP6_COMPARE_FLAG_NONE", "none" },
+        { NM_IP6_COMPARE_FLAG_ADDRESSES, "NM_IP6_COMPARE_FLAG_ADDRESSES", "addresses" },
+        { NM_IP6_COMPARE_FLAG_PTP_ADDRESS, "NM_IP6_COMPARE_FLAG_PTP_ADDRESS", "ptp-address" },
+        { NM_IP6_COMPARE_FLAG_NAMESERVERS, "NM_IP6_COMPARE_FLAG_NAMESERVERS", "nameservers" },
+        { NM_IP6_COMPARE_FLAG_ROUTES, "NM_IP6_COMPARE_FLAG_ROUTES", "routes" },
+        { NM_IP6_COMPARE_FLAG_DOMAINS, "NM_IP6_COMPARE_FLAG_DOMAINS", "domains" },
+        { NM_IP6_COMPARE_FLAG_SEARCHES, "NM_IP6_COMPARE_FLAG_SEARCHES", "searches" },
+        { NM_IP6_COMPARE_FLAG_MSS, "NM_IP6_COMPARE_FLAG_MSS", "mss" },
+        { NM_IP6_COMPARE_FLAG_ALL, "NM_IP6_COMPARE_FLAG_ALL", "all" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("NMConfigError"), values);
+        g_enum_register_static (g_intern_static_string ("NMIP6ConfigCompareFlags"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
   return g_define_type_id__volatile;
 }
 GType
-nm_rf_kill_state_get_type (void)
+nm_auth_call_result_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { RFKILL_UNBLOCKED, "RFKILL_UNBLOCKED", "unblocked" },
-        { RFKILL_SOFT_BLOCKED, "RFKILL_SOFT_BLOCKED", "soft-blocked" },
-        { RFKILL_HARD_BLOCKED, "RFKILL_HARD_BLOCKED", "hard-blocked" },
+        { NM_AUTH_CALL_RESULT_UNKNOWN, "NM_AUTH_CALL_RESULT_UNKNOWN", "unknown" },
+        { NM_AUTH_CALL_RESULT_YES, "NM_AUTH_CALL_RESULT_YES", "yes" },
+        { NM_AUTH_CALL_RESULT_AUTH, "NM_AUTH_CALL_RESULT_AUTH", "auth" },
+        { NM_AUTH_CALL_RESULT_NO, "NM_AUTH_CALL_RESULT_NO", "no" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("RfKillState"), values);
+        g_enum_register_static (g_intern_static_string ("NMAuthCallResult"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
   return g_define_type_id__volatile;
 }
 GType
-nm_rf_kill_type_get_type (void)
+nm_bridge_error_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { RFKILL_TYPE_WLAN, "RFKILL_TYPE_WLAN", "wlan" },
-        { RFKILL_TYPE_WWAN, "RFKILL_TYPE_WWAN", "wwan" },
-        { RFKILL_TYPE_WIMAX, "RFKILL_TYPE_WIMAX", "wimax" },
-        { RFKILL_TYPE_UNKNOWN, "RFKILL_TYPE_UNKNOWN", "unknown" },
-        { RFKILL_TYPE_MAX, "RFKILL_TYPE_MAX", "max" },
+        { NM_BRIDGE_ERROR_CONNECTION_NOT_BRIDGE, "NM_BRIDGE_ERROR_CONNECTION_NOT_BRIDGE", "ConnectionNotBridge" },
+        { NM_BRIDGE_ERROR_CONNECTION_INVALID, "NM_BRIDGE_ERROR_CONNECTION_INVALID", "ConnectionInvalid" },
+        { NM_BRIDGE_ERROR_CONNECTION_INCOMPATIBLE, "NM_BRIDGE_ERROR_CONNECTION_INCOMPATIBLE", "ConnectionIncompatible" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("RfKillType"), values);
+        g_enum_register_static (g_intern_static_string ("NMBridgeError"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
   return g_define_type_id__volatile;
 }
 GType
-nm_bt_error_get_type (void)
+nm_wifi_error_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { NM_BT_ERROR_CONNECTION_NOT_BT, "NM_BT_ERROR_CONNECTION_NOT_BT", "ConnectionNotBt" },
-        { NM_BT_ERROR_CONNECTION_INVALID, "NM_BT_ERROR_CONNECTION_INVALID", "ConnectionInvalid" },
-        { NM_BT_ERROR_CONNECTION_INCOMPATIBLE, "NM_BT_ERROR_CONNECTION_INCOMPATIBLE", "ConnectionIncompatible" },
+        { NM_WIFI_ERROR_CONNECTION_NOT_WIRELESS, "NM_WIFI_ERROR_CONNECTION_NOT_WIRELESS", "ConnectionNotWireless" },
+        { NM_WIFI_ERROR_CONNECTION_INVALID, "NM_WIFI_ERROR_CONNECTION_INVALID", "ConnectionInvalid" },
+        { NM_WIFI_ERROR_CONNECTION_INCOMPATIBLE, "NM_WIFI_ERROR_CONNECTION_INCOMPATIBLE", "ConnectionIncompatible" },
+        { NM_WIFI_ERROR_ACCESS_POINT_NOT_FOUND, "NM_WIFI_ERROR_ACCESS_POINT_NOT_FOUND", "AccessPointNotFound" },
+        { NM_WIFI_ERROR_SCAN_NOT_ALLOWED, "NM_WIFI_ERROR_SCAN_NOT_ALLOWED", "ScanNotAllowed" },
+        { NM_WIFI_ERROR_AP_MODE_UNSUPPORTED, "NM_WIFI_ERROR_AP_MODE_UNSUPPORTED", "ApModeUnsupported" },
+        { NM_WIFI_ERROR_ADHOC_MODE_UNSUPPORTED, "NM_WIFI_ERROR_ADHOC_MODE_UNSUPPORTED", "AdhocModeUnsupported" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("NMBtError"), values);
+        g_enum_register_static (g_intern_static_string ("NMWifiError"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
   return g_define_type_id__volatile;
 }
 GType
-nm_infiniband_error_get_type (void)
+nm_nm_nl_prop_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { NM_INFINIBAND_ERROR_CONNECTION_NOT_INFINIBAND, "NM_INFINIBAND_ERROR_CONNECTION_NOT_INFINIBAND", "ConnectionNotInfiniband" },
-        { NM_INFINIBAND_ERROR_CONNECTION_INVALID, "NM_INFINIBAND_ERROR_CONNECTION_INVALID", "ConnectionInvalid" },
-        { NM_INFINIBAND_ERROR_CONNECTION_INCOMPATIBLE, "NM_INFINIBAND_ERROR_CONNECTION_INCOMPATIBLE", "ConnectionIncompatible" },
+        { NMNL_PROP_INVALID, "NMNL_PROP_INVALID", "invalid" },
+        { NMNL_PROP_PROT, "NMNL_PROP_PROT", "prot" },
+        { NMNL_PROP_SCOPE, "NMNL_PROP_SCOPE", "scope" },
+        { NMNL_PROP_TABLE, "NMNL_PROP_TABLE", "table" },
+        { NMNL_PROP_PRIO, "NMNL_PROP_PRIO", "prio" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("NMInfinibandError"), values);
+        g_enum_register_static (g_intern_static_string ("NmNlProp"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
   return g_define_type_id__volatile;
 }
 GType
-nm_wifi_error_get_type (void)
+nm_vlan_error_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { NM_WIFI_ERROR_CONNECTION_NOT_WIRELESS, "NM_WIFI_ERROR_CONNECTION_NOT_WIRELESS", "ConnectionNotWireless" },
-        { NM_WIFI_ERROR_CONNECTION_INVALID, "NM_WIFI_ERROR_CONNECTION_INVALID", "ConnectionInvalid" },
-        { NM_WIFI_ERROR_CONNECTION_INCOMPATIBLE, "NM_WIFI_ERROR_CONNECTION_INCOMPATIBLE", "ConnectionIncompatible" },
-        { NM_WIFI_ERROR_ACCESS_POINT_NOT_FOUND, "NM_WIFI_ERROR_ACCESS_POINT_NOT_FOUND", "AccessPointNotFound" },
-        { NM_WIFI_ERROR_SCAN_NOT_ALLOWED, "NM_WIFI_ERROR_SCAN_NOT_ALLOWED", "ScanNotAllowed" },
-        { NM_WIFI_ERROR_AP_MODE_UNSUPPORTED, "NM_WIFI_ERROR_AP_MODE_UNSUPPORTED", "ApModeUnsupported" },
-        { NM_WIFI_ERROR_ADHOC_MODE_UNSUPPORTED, "NM_WIFI_ERROR_ADHOC_MODE_UNSUPPORTED", "AdhocModeUnsupported" },
+        { NM_VLAN_ERROR_CONNECTION_NOT_VLAN, "NM_VLAN_ERROR_CONNECTION_NOT_VLAN", "ConnectionNotVlan" },
+        { NM_VLAN_ERROR_CONNECTION_INVALID, "NM_VLAN_ERROR_CONNECTION_INVALID", "ConnectionInvalid" },
+        { NM_VLAN_ERROR_CONNECTION_INCOMPATIBLE, "NM_VLAN_ERROR_CONNECTION_INCOMPATIBLE", "ConnectionIncompatible" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("NMWifiError"), values);
+        g_enum_register_static (g_intern_static_string ("NMVlanError"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
   return g_define_type_id__volatile;
 }
 GType
-nm_session_monitor_error_get_type (void)
+nm_netlink_monitor_error_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { NM_SESSION_MONITOR_ERROR_IO_ERROR, "NM_SESSION_MONITOR_ERROR_IO_ERROR", "IOError" },
-        { NM_SESSION_MONITOR_ERROR_MALFORMED_DATABASE, "NM_SESSION_MONITOR_ERROR_MALFORMED_DATABASE", "MalformedDatabase" },
-        { NM_SESSION_MONITOR_ERROR_UNKNOWN_USER, "NM_SESSION_MONITOR_ERROR_UNKNOWN_USER", "UnknownUser" },
-        { NM_SESSION_MONITOR_ERROR_NO_DATABASE, "NM_SESSION_MONITOR_ERROR_NO_DATABASE", "NoDatabase" },
+        { NM_NETLINK_MONITOR_ERROR_GENERIC, "NM_NETLINK_MONITOR_ERROR_GENERIC", "generic" },
+        { NM_NETLINK_MONITOR_ERROR_NETLINK_ALLOC_HANDLE, "NM_NETLINK_MONITOR_ERROR_NETLINK_ALLOC_HANDLE", "netlink-alloc-handle" },
+        { NM_NETLINK_MONITOR_ERROR_NETLINK_CONNECT, "NM_NETLINK_MONITOR_ERROR_NETLINK_CONNECT", "netlink-connect" },
+        { NM_NETLINK_MONITOR_ERROR_NETLINK_JOIN_GROUP, "NM_NETLINK_MONITOR_ERROR_NETLINK_JOIN_GROUP", "netlink-join-group" },
+        { NM_NETLINK_MONITOR_ERROR_NETLINK_ALLOC_LINK_CACHE, "NM_NETLINK_MONITOR_ERROR_NETLINK_ALLOC_LINK_CACHE", "netlink-alloc-link-cache" },
+        { NM_NETLINK_MONITOR_ERROR_PROCESSING_MESSAGE, "NM_NETLINK_MONITOR_ERROR_PROCESSING_MESSAGE", "processing-message" },
+        { NM_NETLINK_MONITOR_ERROR_BAD_ALLOC, "NM_NETLINK_MONITOR_ERROR_BAD_ALLOC", "bad-alloc" },
+        { NM_NETLINK_MONITOR_ERROR_WAITING_FOR_SOCKET_DATA, "NM_NETLINK_MONITOR_ERROR_WAITING_FOR_SOCKET_DATA", "waiting-for-socket-data" },
+        { NM_NETLINK_MONITOR_ERROR_LINK_CACHE_UPDATE, "NM_NETLINK_MONITOR_ERROR_LINK_CACHE_UPDATE", "link-cache-update" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("NMSessionMonitorError"), values);
+        g_enum_register_static (g_intern_static_string ("NMNetlinkMonitorError"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
   return g_define_type_id__volatile;
 }
 GType
-nm_ethernet_error_get_type (void)
+nm_olpc_mesh_error_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { NM_ETHERNET_ERROR_CONNECTION_NOT_WIRED, "NM_ETHERNET_ERROR_CONNECTION_NOT_WIRED", "ConnectionNotWired" },
-        { NM_ETHERNET_ERROR_CONNECTION_INVALID, "NM_ETHERNET_ERROR_CONNECTION_INVALID", "ConnectionInvalid" },
-        { NM_ETHERNET_ERROR_CONNECTION_INCOMPATIBLE, "NM_ETHERNET_ERROR_CONNECTION_INCOMPATIBLE", "ConnectionIncompatible" },
+        { NM_OLPC_MESH_ERROR_CONNECTION_NOT_MESH, "NM_OLPC_MESH_ERROR_CONNECTION_NOT_MESH", "ConnectionNotMesh" },
+        { NM_OLPC_MESH_ERROR_CONNECTION_INVALID, "NM_OLPC_MESH_ERROR_CONNECTION_INVALID", "ConnectionInvalid" },
+        { NM_OLPC_MESH_ERROR_CONNECTION_INCOMPATIBLE, "NM_OLPC_MESH_ERROR_CONNECTION_INCOMPATIBLE", "ConnectionIncompatible" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("NMEthernetError"), values);
+        g_enum_register_static (g_intern_static_string ("NMOlpcMeshError"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
   return g_define_type_id__volatile;
 }
 GType
-nm_dispatcher_action_get_type (void)
+nm_adsl_error_get_type (void)
 {
   static volatile gsize g_define_type_id__volatile = 0;
 
   if (g_once_init_enter (&g_define_type_id__volatile))
     {
       static const GEnumValue values[] = {
-        { DISPATCHER_ACTION_HOSTNAME, "DISPATCHER_ACTION_HOSTNAME", "hostname" },
-        { DISPATCHER_ACTION_UP, "DISPATCHER_ACTION_UP", "up" },
-        { DISPATCHER_ACTION_PRE_DOWN, "DISPATCHER_ACTION_PRE_DOWN", "pre-down" },
-        { DISPATCHER_ACTION_DOWN, "DISPATCHER_ACTION_DOWN", "down" },
-        { DISPATCHER_ACTION_VPN_UP, "DISPATCHER_ACTION_VPN_UP", "vpn-up" },
-        { DISPATCHER_ACTION_VPN_PRE_DOWN, "DISPATCHER_ACTION_VPN_PRE_DOWN", "vpn-pre-down" },
-        { DISPATCHER_ACTION_VPN_DOWN, "DISPATCHER_ACTION_VPN_DOWN", "vpn-down" },
-        { DISPATCHER_ACTION_DHCP4_CHANGE, "DISPATCHER_ACTION_DHCP4_CHANGE", "dhcp4-change" },
-        { DISPATCHER_ACTION_DHCP6_CHANGE, "DISPATCHER_ACTION_DHCP6_CHANGE", "dhcp6-change" },
+        { NM_ADSL_ERROR_CONNECTION_NOT_ADSL, "NM_ADSL_ERROR_CONNECTION_NOT_ADSL", "ConnectionNotAdsl" },
+        { NM_ADSL_ERROR_CONNECTION_INVALID, "NM_ADSL_ERROR_CONNECTION_INVALID", "ConnectionInvalid" },
+        { NM_ADSL_ERROR_CONNECTION_INCOMPATIBLE, "NM_ADSL_ERROR_CONNECTION_INCOMPATIBLE", "ConnectionIncompatible" },
         { 0, NULL, NULL }
       };
       GType g_define_type_id =
-        g_enum_register_static (g_intern_static_string ("DispatcherAction"), values);
+        g_enum_register_static (g_intern_static_string ("NMAdslError"), values);
       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
     }
 
@@ -954,6 +954,7 @@ nm_settings_error_get_type (void)
         { NM_SETTINGS_ERROR_ADD_FAILED, "NM_SETTINGS_ERROR_ADD_FAILED", "AddFailed" },
         { NM_SETTINGS_ERROR_SAVE_HOSTNAME_NOT_SUPPORTED, "NM_SETTINGS_ERROR_SAVE_HOSTNAME_NOT_SUPPORTED", "SaveHostnameNotSupported" },
         { NM_SETTINGS_ERROR_SAVE_HOSTNAME_FAILED, "NM_SETTINGS_ERROR_SAVE_HOSTNAME_FAILED", "SaveHostnameFailed" },
+        { NM_SETTINGS_ERROR_HOSTNAME_INVALID, "NM_SETTINGS_ERROR_HOSTNAME_INVALID", "HostnameInvalid" },
         { NM_SETTINGS_ERROR_UUID_EXISTS, "NM_SETTINGS_ERROR_UUID_EXISTS", "UuidExists" },
         { 0, NULL, NULL }
       };
diff --git a/src/generated/nm-enum-types.h b/src/generated/nm-enum-types.h
index 9c53b188..e0703b20 100644
--- a/src/generated/nm-enum-types.h
+++ b/src/generated/nm-enum-types.h
@@ -9,48 +9,48 @@
 #include <glib-object.h>
 
 G_BEGIN_DECLS
+GType nm_bt_error_get_type (void) G_GNUC_CONST;
+#define NM_TYPE_BT_ERROR (nm_bt_error_get_type ())
+GType nm_infiniband_error_get_type (void) G_GNUC_CONST;
+#define NM_TYPE_INFINIBAND_ERROR (nm_infiniband_error_get_type ())
+GType nm_bond_error_get_type (void) G_GNUC_CONST;
+#define NM_TYPE_BOND_ERROR (nm_bond_error_get_type ())
+GType nm_session_monitor_error_get_type (void) G_GNUC_CONST;
+#define NM_TYPE_SESSION_MONITOR_ERROR (nm_session_monitor_error_get_type ())
+GType nm_ethernet_error_get_type (void) G_GNUC_CONST;
+#define NM_TYPE_ETHERNET_ERROR (nm_ethernet_error_get_type ())
+GType nm_config_error_get_type (void) G_GNUC_CONST;
+#define NM_TYPE_CONFIG_ERROR (nm_config_error_get_type ())
+GType nm_rf_kill_state_get_type (void) G_GNUC_CONST;
+#define NM_TYPE_RF_KILL_STATE (nm_rf_kill_state_get_type ())
+GType nm_rf_kill_type_get_type (void) G_GNUC_CONST;
+#define NM_TYPE_RF_KILL_TYPE (nm_rf_kill_type_get_type ())
+GType nm_dispatcher_action_get_type (void) G_GNUC_CONST;
+#define NM_TYPE_DISPATCHER_ACTION (nm_dispatcher_action_get_type ())
+GType nm_ip4_config_compare_flags_get_type (void) G_GNUC_CONST;
+#define NM_TYPE_IP4_CONFIG_COMPARE_FLAGS (nm_ip4_config_compare_flags_get_type ())
 GType nm_manager_error_get_type (void) G_GNUC_CONST;
 #define NM_TYPE_MANAGER_ERROR (nm_manager_error_get_type ())
+GType nm_device_error_get_type (void) G_GNUC_CONST;
+#define NM_TYPE_DEVICE_ERROR (nm_device_error_get_type ())
+GType nm_ip6_config_compare_flags_get_type (void) G_GNUC_CONST;
+#define NM_TYPE_IP6_CONFIG_COMPARE_FLAGS (nm_ip6_config_compare_flags_get_type ())
 GType nm_auth_call_result_get_type (void) G_GNUC_CONST;
 #define NM_TYPE_AUTH_CALL_RESULT (nm_auth_call_result_get_type ())
+GType nm_bridge_error_get_type (void) G_GNUC_CONST;
+#define NM_TYPE_BRIDGE_ERROR (nm_bridge_error_get_type ())
+GType nm_wifi_error_get_type (void) G_GNUC_CONST;
+#define NM_TYPE_WIFI_ERROR (nm_wifi_error_get_type ())
 GType nm_nm_nl_prop_get_type (void) G_GNUC_CONST;
 #define NM_TYPE_NM_NL_PROP (nm_nm_nl_prop_get_type ())
-GType nm_netlink_monitor_error_get_type (void) G_GNUC_CONST;
-#define NM_TYPE_NETLINK_MONITOR_ERROR (nm_netlink_monitor_error_get_type ())
 GType nm_vlan_error_get_type (void) G_GNUC_CONST;
 #define NM_TYPE_VLAN_ERROR (nm_vlan_error_get_type ())
-GType nm_ip4_config_compare_flags_get_type (void) G_GNUC_CONST;
-#define NM_TYPE_IP4_CONFIG_COMPARE_FLAGS (nm_ip4_config_compare_flags_get_type ())
-GType nm_device_error_get_type (void) G_GNUC_CONST;
-#define NM_TYPE_DEVICE_ERROR (nm_device_error_get_type ())
+GType nm_netlink_monitor_error_get_type (void) G_GNUC_CONST;
+#define NM_TYPE_NETLINK_MONITOR_ERROR (nm_netlink_monitor_error_get_type ())
 GType nm_olpc_mesh_error_get_type (void) G_GNUC_CONST;
 #define NM_TYPE_OLPC_MESH_ERROR (nm_olpc_mesh_error_get_type ())
-GType nm_bridge_error_get_type (void) G_GNUC_CONST;
-#define NM_TYPE_BRIDGE_ERROR (nm_bridge_error_get_type ())
-GType nm_ip6_config_compare_flags_get_type (void) G_GNUC_CONST;
-#define NM_TYPE_IP6_CONFIG_COMPARE_FLAGS (nm_ip6_config_compare_flags_get_type ())
-GType nm_bond_error_get_type (void) G_GNUC_CONST;
-#define NM_TYPE_BOND_ERROR (nm_bond_error_get_type ())
 GType nm_adsl_error_get_type (void) G_GNUC_CONST;
 #define NM_TYPE_ADSL_ERROR (nm_adsl_error_get_type ())
-GType nm_config_error_get_type (void) G_GNUC_CONST;
-#define NM_TYPE_CONFIG_ERROR (nm_config_error_get_type ())
-GType nm_rf_kill_state_get_type (void) G_GNUC_CONST;
-#define NM_TYPE_RF_KILL_STATE (nm_rf_kill_state_get_type ())
-GType nm_rf_kill_type_get_type (void) G_GNUC_CONST;
-#define NM_TYPE_RF_KILL_TYPE (nm_rf_kill_type_get_type ())
-GType nm_bt_error_get_type (void) G_GNUC_CONST;
-#define NM_TYPE_BT_ERROR (nm_bt_error_get_type ())
-GType nm_infiniband_error_get_type (void) G_GNUC_CONST;
-#define NM_TYPE_INFINIBAND_ERROR (nm_infiniband_error_get_type ())
-GType nm_wifi_error_get_type (void) G_GNUC_CONST;
-#define NM_TYPE_WIFI_ERROR (nm_wifi_error_get_type ())
-GType nm_session_monitor_error_get_type (void) G_GNUC_CONST;
-#define NM_TYPE_SESSION_MONITOR_ERROR (nm_session_monitor_error_get_type ())
-GType nm_ethernet_error_get_type (void) G_GNUC_CONST;
-#define NM_TYPE_ETHERNET_ERROR (nm_ethernet_error_get_type ())
-GType nm_dispatcher_action_get_type (void) G_GNUC_CONST;
-#define NM_TYPE_DISPATCHER_ACTION (nm_dispatcher_action_get_type ())
 GType nm_logging_error_get_type (void) G_GNUC_CONST;
 #define NM_TYPE_LOGGING_ERROR (nm_logging_error_get_type ())
 GType nm_dns_manager_error_get_type (void) G_GNUC_CONST;
diff --git a/src/generated/nm-marshal.c b/src/generated/nm-marshal.c
index f6ff4eca..c7180f1b 100644
--- a/src/generated/nm-marshal.c
+++ b/src/generated/nm-marshal.c
@@ -319,24 +319,28 @@ _nm_marshal_VOID__POINTER_POINTER_POINTER_POINTER_INT (GClosure     *closure,
             data2);
 }
 
-/* VOID:POINTER,STRING (nm-marshal.list:9) */
+/* VOID:POINTER,POINTER,STRING,BOOLEAN,POINTER,POINTER (nm-marshal.list:9) */
 void
-_nm_marshal_VOID__POINTER_STRING (GClosure     *closure,
-                                  GValue       *return_value G_GNUC_UNUSED,
-                                  guint         n_param_values,
-                                  const GValue *param_values,
-                                  gpointer      invocation_hint G_GNUC_UNUSED,
-                                  gpointer      marshal_data)
+_nm_marshal_VOID__POINTER_POINTER_STRING_BOOLEAN_POINTER_POINTER (GClosure     *closure,
+                                                                  GValue       *return_value G_GNUC_UNUSED,
+                                                                  guint         n_param_values,
+                                                                  const GValue *param_values,
+                                                                  gpointer      invocation_hint G_GNUC_UNUSED,
+                                                                  gpointer      marshal_data)
 {
-  typedef void (*GMarshalFunc_VOID__POINTER_STRING) (gpointer     data1,
-                                                     gpointer     arg_1,
-                                                     gpointer     arg_2,
-                                                     gpointer     data2);
-  register GMarshalFunc_VOID__POINTER_STRING callback;
+  typedef void (*GMarshalFunc_VOID__POINTER_POINTER_STRING_BOOLEAN_POINTER_POINTER) (gpointer     data1,
+                                                                                     gpointer     arg_1,
+                                                                                     gpointer     arg_2,
+                                                                                     gpointer     arg_3,
+                                                                                     gboolean     arg_4,
+                                                                                     gpointer     arg_5,
+                                                                                     gpointer     arg_6,
+                                                                                     gpointer     data2);
+  register GMarshalFunc_VOID__POINTER_POINTER_STRING_BOOLEAN_POINTER_POINTER callback;
   register GCClosure *cc = (GCClosure*) closure;
   register gpointer data1, data2;
 
-  g_return_if_fail (n_param_values == 3);
+  g_return_if_fail (n_param_values == 7);
 
   if (G_CCLOSURE_SWAP_DATA (closure))
     {
@@ -348,35 +352,36 @@ _nm_marshal_VOID__POINTER_STRING (GClosure     *closure,
       data1 = g_value_peek_pointer (param_values + 0);
       data2 = closure->data;
     }
-  callback = (GMarshalFunc_VOID__POINTER_STRING) (marshal_data ? marshal_data : cc->callback);
+  callback = (GMarshalFunc_VOID__POINTER_POINTER_STRING_BOOLEAN_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
 
   callback (data1,
             g_marshal_value_peek_pointer (param_values + 1),
-            g_marshal_value_peek_string (param_values + 2),
+            g_marshal_value_peek_pointer (param_values + 2),
+            g_marshal_value_peek_string (param_values + 3),
+            g_marshal_value_peek_boolean (param_values + 4),
+            g_marshal_value_peek_pointer (param_values + 5),
+            g_marshal_value_peek_pointer (param_values + 6),
             data2);
 }
 
-/* VOID:POINTER,STRING,BOOLEAN,POINTER,POINTER (nm-marshal.list:10) */
+/* VOID:POINTER,STRING (nm-marshal.list:10) */
 void
-_nm_marshal_VOID__POINTER_STRING_BOOLEAN_POINTER_POINTER (GClosure     *closure,
-                                                          GValue       *return_value G_GNUC_UNUSED,
-                                                          guint         n_param_values,
-                                                          const GValue *param_values,
-                                                          gpointer      invocation_hint G_GNUC_UNUSED,
-                                                          gpointer      marshal_data)
+_nm_marshal_VOID__POINTER_STRING (GClosure     *closure,
+                                  GValue       *return_value G_GNUC_UNUSED,
+                                  guint         n_param_values,
+                                  const GValue *param_values,
+                                  gpointer      invocation_hint G_GNUC_UNUSED,
+                                  gpointer      marshal_data)
 {
-  typedef void (*GMarshalFunc_VOID__POINTER_STRING_BOOLEAN_POINTER_POINTER) (gpointer     data1,
-                                                                             gpointer     arg_1,
-                                                                             gpointer     arg_2,
-                                                                             gboolean     arg_3,
-                                                                             gpointer     arg_4,
-                                                                             gpointer     arg_5,
-                                                                             gpointer     data2);
-  register GMarshalFunc_VOID__POINTER_STRING_BOOLEAN_POINTER_POINTER callback;
+  typedef void (*GMarshalFunc_VOID__POINTER_STRING) (gpointer     data1,
+                                                     gpointer     arg_1,
+                                                     gpointer     arg_2,
+                                                     gpointer     data2);
+  register GMarshalFunc_VOID__POINTER_STRING callback;
   register GCClosure *cc = (GCClosure*) closure;
   register gpointer data1, data2;
 
-  g_return_if_fail (n_param_values == 6);
+  g_return_if_fail (n_param_values == 3);
 
   if (G_CCLOSURE_SWAP_DATA (closure))
     {
@@ -388,14 +393,11 @@ _nm_marshal_VOID__POINTER_STRING_BOOLEAN_POINTER_POINTER (GClosure     *closure,
       data1 = g_value_peek_pointer (param_values + 0);
       data2 = closure->data;
     }
-  callback = (GMarshalFunc_VOID__POINTER_STRING_BOOLEAN_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
+  callback = (GMarshalFunc_VOID__POINTER_STRING) (marshal_data ? marshal_data : cc->callback);
 
   callback (data1,
             g_marshal_value_peek_pointer (param_values + 1),
             g_marshal_value_peek_string (param_values + 2),
-            g_marshal_value_peek_boolean (param_values + 3),
-            g_marshal_value_peek_pointer (param_values + 4),
-            g_marshal_value_peek_pointer (param_values + 5),
             data2);
 }
 
diff --git a/src/generated/nm-marshal.h b/src/generated/nm-marshal.h
index e93cee13..a940d9f1 100644
--- a/src/generated/nm-marshal.h
+++ b/src/generated/nm-marshal.h
@@ -65,7 +65,15 @@ extern void _nm_marshal_VOID__POINTER_POINTER_POINTER_POINTER_INT (GClosure
                                                                    gpointer      invocation_hint,
                                                                    gpointer      marshal_data);
 
-/* VOID:POINTER,STRING (nm-marshal.list:9) */
+/* VOID:POINTER,POINTER,STRING,BOOLEAN,POINTER,POINTER (nm-marshal.list:9) */
+extern void _nm_marshal_VOID__POINTER_POINTER_STRING_BOOLEAN_POINTER_POINTER (GClosure     *closure,
+                                                                              GValue       *return_value,
+                                                                              guint         n_param_values,
+                                                                              const GValue *param_values,
+                                                                              gpointer      invocation_hint,
+                                                                              gpointer      marshal_data);
+
+/* VOID:POINTER,STRING (nm-marshal.list:10) */
 extern void _nm_marshal_VOID__POINTER_STRING (GClosure     *closure,
                                               GValue       *return_value,
                                               guint         n_param_values,
@@ -73,14 +81,6 @@ extern void _nm_marshal_VOID__POINTER_STRING (GClosure     *closure,
                                               gpointer      invocation_hint,
                                               gpointer      marshal_data);
 
-/* VOID:POINTER,STRING,BOOLEAN,POINTER,POINTER (nm-marshal.list:10) */
-extern void _nm_marshal_VOID__POINTER_STRING_BOOLEAN_POINTER_POINTER (GClosure     *closure,
-                                                                      GValue       *return_value,
-                                                                      guint         n_param_values,
-                                                                      const GValue *param_values,
-                                                                      gpointer      invocation_hint,
-                                                                      gpointer      marshal_data);
-
 /* VOID:STRING,BOXED (nm-marshal.list:11) */
 extern void _nm_marshal_VOID__STRING_BOXED (GClosure     *closure,
                                             GValue       *return_value,