
/* 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 "qmi-flag-types.h"
/* enumerations from "../git/src/libqmi-glib/qmi-device.h" */
static const GFlagsValue qmi_device_open_flags_values[] = {
    { QMI_DEVICE_OPEN_FLAGS_NONE, "QMI_DEVICE_OPEN_FLAGS_NONE", "none" },
    { QMI_DEVICE_OPEN_FLAGS_VERSION_INFO, "QMI_DEVICE_OPEN_FLAGS_VERSION_INFO", "version-info" },
    { QMI_DEVICE_OPEN_FLAGS_SYNC, "QMI_DEVICE_OPEN_FLAGS_SYNC", "sync" },
    { QMI_DEVICE_OPEN_FLAGS_NET_802_3, "QMI_DEVICE_OPEN_FLAGS_NET_802_3", "net-802-3" },
    { QMI_DEVICE_OPEN_FLAGS_NET_RAW_IP, "QMI_DEVICE_OPEN_FLAGS_NET_RAW_IP", "net-raw-ip" },
    { QMI_DEVICE_OPEN_FLAGS_NET_QOS_HEADER, "QMI_DEVICE_OPEN_FLAGS_NET_QOS_HEADER", "net-qos-header" },
    { QMI_DEVICE_OPEN_FLAGS_NET_NO_QOS_HEADER, "QMI_DEVICE_OPEN_FLAGS_NET_NO_QOS_HEADER", "net-no-qos-header" },
    { QMI_DEVICE_OPEN_FLAGS_PROXY, "QMI_DEVICE_OPEN_FLAGS_PROXY", "proxy" },
    { QMI_DEVICE_OPEN_FLAGS_MBIM, "QMI_DEVICE_OPEN_FLAGS_MBIM", "mbim" },
    { QMI_DEVICE_OPEN_FLAGS_AUTO, "QMI_DEVICE_OPEN_FLAGS_AUTO", "auto" },
    { QMI_DEVICE_OPEN_FLAGS_EXPECT_INDICATIONS, "QMI_DEVICE_OPEN_FLAGS_EXPECT_INDICATIONS", "expect-indications" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_device_open_flags_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiDeviceOpenFlags"),
                                      qmi_device_open_flags_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_device_open_flags_build_string_from_mask (QmiDeviceOpenFlags mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_device_open_flags_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_device_open_flags_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_device_open_flags_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_device_open_flags_values[i].value) {
            guint c;
            gulong number = qmi_device_open_flags_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_device_open_flags_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_device_release_client_flags_values[] = {
    { QMI_DEVICE_RELEASE_CLIENT_FLAGS_NONE, "QMI_DEVICE_RELEASE_CLIENT_FLAGS_NONE", "none" },
    { QMI_DEVICE_RELEASE_CLIENT_FLAGS_RELEASE_CID, "QMI_DEVICE_RELEASE_CLIENT_FLAGS_RELEASE_CID", "release-cid" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_device_release_client_flags_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiDeviceReleaseClientFlags"),
                                      qmi_device_release_client_flags_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_device_release_client_flags_build_string_from_mask (QmiDeviceReleaseClientFlags mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_device_release_client_flags_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_device_release_client_flags_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_device_release_client_flags_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_device_release_client_flags_values[i].value) {
            guint c;
            gulong number = qmi_device_release_client_flags_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_device_release_client_flags_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_device_add_link_flags_values[] = {
    { QMI_DEVICE_ADD_LINK_FLAGS_NONE, "QMI_DEVICE_ADD_LINK_FLAGS_NONE", "none" },
    { QMI_DEVICE_ADD_LINK_FLAGS_INGRESS_MAP_CKSUMV4, "QMI_DEVICE_ADD_LINK_FLAGS_INGRESS_MAP_CKSUMV4", "ingress-map-cksumv4" },
    { QMI_DEVICE_ADD_LINK_FLAGS_EGRESS_MAP_CKSUMV4, "QMI_DEVICE_ADD_LINK_FLAGS_EGRESS_MAP_CKSUMV4", "egress-map-cksumv4" },
    { QMI_DEVICE_ADD_LINK_FLAGS_INGRESS_MAP_CKSUMV5, "QMI_DEVICE_ADD_LINK_FLAGS_INGRESS_MAP_CKSUMV5", "ingress-map-cksumv5" },
    { QMI_DEVICE_ADD_LINK_FLAGS_EGRESS_MAP_CKSUMV5, "QMI_DEVICE_ADD_LINK_FLAGS_EGRESS_MAP_CKSUMV5", "egress-map-cksumv5" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_device_add_link_flags_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiDeviceAddLinkFlags"),
                                      qmi_device_add_link_flags_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_device_add_link_flags_build_string_from_mask (QmiDeviceAddLinkFlags mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_device_add_link_flags_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_device_add_link_flags_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_device_add_link_flags_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_device_add_link_flags_values[i].value) {
            guint c;
            gulong number = qmi_device_add_link_flags_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_device_add_link_flags_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
/* enumerations from "../git/src/libqmi-glib/qmi-enums-dms.h" */
static const GFlagsValue qmi_dms_power_state_values[] = {
    { QMI_DMS_POWER_STATE_EXTERNAL_SOURCE, "QMI_DMS_POWER_STATE_EXTERNAL_SOURCE", "external-source" },
    { QMI_DMS_POWER_STATE_BATTERY_CONNECTED, "QMI_DMS_POWER_STATE_BATTERY_CONNECTED", "battery-connected" },
    { QMI_DMS_POWER_STATE_BATTERY_CHARGING, "QMI_DMS_POWER_STATE_BATTERY_CHARGING", "battery-charging" },
    { QMI_DMS_POWER_STATE_FAULT, "QMI_DMS_POWER_STATE_FAULT", "fault" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_dms_power_state_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiDmsPowerState"),
                                      qmi_dms_power_state_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_dms_power_state_build_string_from_mask (QmiDmsPowerState mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_dms_power_state_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_dms_power_state_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_dms_power_state_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_dms_power_state_values[i].value) {
            guint c;
            gulong number = qmi_dms_power_state_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_dms_power_state_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_dms_offline_reason_values[] = {
    { QMI_DMS_OFFLINE_REASON_HOST_IMAGE_MISCONFIGURATION, "QMI_DMS_OFFLINE_REASON_HOST_IMAGE_MISCONFIGURATION", "host-image-misconfiguration" },
    { QMI_DMS_OFFLINE_REASON_PRI_IMAGE_MISCONFIGURATION, "QMI_DMS_OFFLINE_REASON_PRI_IMAGE_MISCONFIGURATION", "pri-image-misconfiguration" },
    { QMI_DMS_OFFLINE_REASON_PRI_VERSION_INCOMPATIBLE, "QMI_DMS_OFFLINE_REASON_PRI_VERSION_INCOMPATIBLE", "pri-version-incompatible" },
    { QMI_DMS_OFFLINE_REASON_DEVICE_MEMORY_FULL, "QMI_DMS_OFFLINE_REASON_DEVICE_MEMORY_FULL", "device-memory-full" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_dms_offline_reason_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiDmsOfflineReason"),
                                      qmi_dms_offline_reason_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_dms_offline_reason_build_string_from_mask (QmiDmsOfflineReason mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_dms_offline_reason_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_dms_offline_reason_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_dms_offline_reason_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_dms_offline_reason_values[i].value) {
            guint c;
            gulong number = qmi_dms_offline_reason_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_dms_offline_reason_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
/* enumerations from "../git/src/libqmi-glib/qmi-enums-loc.h" */
static const GFlagsValue qmi_loc_technology_used_values[] = {
    { QMI_LOC_TECHNOLOGY_USED_SATELLITE, "QMI_LOC_TECHNOLOGY_USED_SATELLITE", "satellite" },
    { QMI_LOC_TECHNOLOGY_USED_CELLULAR, "QMI_LOC_TECHNOLOGY_USED_CELLULAR", "cellular" },
    { QMI_LOC_TECHNOLOGY_USED_WIFI, "QMI_LOC_TECHNOLOGY_USED_WIFI", "wifi" },
    { QMI_LOC_TECHNOLOGY_USED_SENSORS, "QMI_LOC_TECHNOLOGY_USED_SENSORS", "sensors" },
    { QMI_LOC_TECHNOLOGY_USED_REFERENCE_LOCATION, "QMI_LOC_TECHNOLOGY_USED_REFERENCE_LOCATION", "reference-location" },
    { QMI_LOC_TECHNOLOGY_USED_INJECTED_POSITION, "QMI_LOC_TECHNOLOGY_USED_INJECTED_POSITION", "injected-position" },
    { QMI_LOC_TECHNOLOGY_USED_AFLT, "QMI_LOC_TECHNOLOGY_USED_AFLT", "aflt" },
    { QMI_LOC_TECHNOLOGY_USED_HYBRID, "QMI_LOC_TECHNOLOGY_USED_HYBRID", "hybrid" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_loc_technology_used_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiLocTechnologyUsed"),
                                      qmi_loc_technology_used_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_loc_technology_used_build_string_from_mask (QmiLocTechnologyUsed mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_loc_technology_used_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_loc_technology_used_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_loc_technology_used_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_loc_technology_used_values[i].value) {
            guint c;
            gulong number = qmi_loc_technology_used_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_loc_technology_used_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_loc_satellite_valid_information_values[] = {
    { QMI_LOC_SATELLITE_VALID_INFORMATION_SYSTEM, "QMI_LOC_SATELLITE_VALID_INFORMATION_SYSTEM", "system" },
    { QMI_LOC_SATELLITE_VALID_INFORMATION_GNSS_SATELLITE_ID, "QMI_LOC_SATELLITE_VALID_INFORMATION_GNSS_SATELLITE_ID", "gnss-satellite-id" },
    { QMI_LOC_SATELLITE_VALID_INFORMATION_HEALTH_STATUS, "QMI_LOC_SATELLITE_VALID_INFORMATION_HEALTH_STATUS", "health-status" },
    { QMI_LOC_SATELLITE_VALID_INFORMATION_PROCESS_STATUS, "QMI_LOC_SATELLITE_VALID_INFORMATION_PROCESS_STATUS", "process-status" },
    { QMI_LOC_SATELLITE_VALID_INFORMATION_SATELLITE_INFO_MASK, "QMI_LOC_SATELLITE_VALID_INFORMATION_SATELLITE_INFO_MASK", "satellite-info-mask" },
    { QMI_LOC_SATELLITE_VALID_INFORMATION_ELEVATION, "QMI_LOC_SATELLITE_VALID_INFORMATION_ELEVATION", "elevation" },
    { QMI_LOC_SATELLITE_VALID_INFORMATION_AZIMUTH, "QMI_LOC_SATELLITE_VALID_INFORMATION_AZIMUTH", "azimuth" },
    { QMI_LOC_SATELLITE_VALID_INFORMATION_SIGNAL_TO_NOISE_RATIO, "QMI_LOC_SATELLITE_VALID_INFORMATION_SIGNAL_TO_NOISE_RATIO", "signal-to-noise-ratio" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_loc_satellite_valid_information_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiLocSatelliteValidInformation"),
                                      qmi_loc_satellite_valid_information_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_loc_satellite_valid_information_build_string_from_mask (QmiLocSatelliteValidInformation mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_loc_satellite_valid_information_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_loc_satellite_valid_information_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_loc_satellite_valid_information_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_loc_satellite_valid_information_values[i].value) {
            guint c;
            gulong number = qmi_loc_satellite_valid_information_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_loc_satellite_valid_information_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_loc_server_address_type_values[] = {
    { QMI_LOC_SERVER_ADDRESS_TYPE_NONE, "QMI_LOC_SERVER_ADDRESS_TYPE_NONE", "none" },
    { QMI_LOC_SERVER_ADDRESS_TYPE_IPV4, "QMI_LOC_SERVER_ADDRESS_TYPE_IPV4", "ipv4" },
    { QMI_LOC_SERVER_ADDRESS_TYPE_IPV6, "QMI_LOC_SERVER_ADDRESS_TYPE_IPV6", "ipv6" },
    { QMI_LOC_SERVER_ADDRESS_TYPE_URL, "QMI_LOC_SERVER_ADDRESS_TYPE_URL", "url" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_loc_server_address_type_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiLocServerAddressType"),
                                      qmi_loc_server_address_type_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_loc_server_address_type_build_string_from_mask (QmiLocServerAddressType mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_loc_server_address_type_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_loc_server_address_type_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_loc_server_address_type_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_loc_server_address_type_values[i].value) {
            guint c;
            gulong number = qmi_loc_server_address_type_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_loc_server_address_type_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_loc_delete_sv_info_values[] = {
    { QMI_LOC_DELETE_SV_INFO_EPHEMERIS, "QMI_LOC_DELETE_SV_INFO_EPHEMERIS", "ephemeris" },
    { QMI_LOC_DELETE_SV_INFO_ALMANAC, "QMI_LOC_DELETE_SV_INFO_ALMANAC", "almanac" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_loc_delete_sv_info_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiLocDeleteSvInfo"),
                                      qmi_loc_delete_sv_info_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_loc_delete_sv_info_build_string_from_mask (QmiLocDeleteSvInfo mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_loc_delete_sv_info_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_loc_delete_sv_info_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_loc_delete_sv_info_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_loc_delete_sv_info_values[i].value) {
            guint c;
            gulong number = qmi_loc_delete_sv_info_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_loc_delete_sv_info_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_loc_delete_cell_database_values[] = {
    { QMI_LOC_DELETE_CELL_DATABASE_POS, "QMI_LOC_DELETE_CELL_DATABASE_POS", "pos" },
    { QMI_LOC_DELETE_CELL_DATABASE_LATEST_GPS_POS, "QMI_LOC_DELETE_CELL_DATABASE_LATEST_GPS_POS", "latest-gps-pos" },
    { QMI_LOC_DELETE_CELL_DATABASE_OTA_POS, "QMI_LOC_DELETE_CELL_DATABASE_OTA_POS", "ota-pos" },
    { QMI_LOC_DELETE_CELL_DATABASE_EXT_REF_POS, "QMI_LOC_DELETE_CELL_DATABASE_EXT_REF_POS", "ext-ref-pos" },
    { QMI_LOC_DELETE_CELL_DATABASE_TIMETAG, "QMI_LOC_DELETE_CELL_DATABASE_TIMETAG", "timetag" },
    { QMI_LOC_DELETE_CELL_DATABASE_CELLID, "QMI_LOC_DELETE_CELL_DATABASE_CELLID", "cellid" },
    { QMI_LOC_DELETE_CELL_DATABASE_CACHED_CELLID, "QMI_LOC_DELETE_CELL_DATABASE_CACHED_CELLID", "cached-cellid" },
    { QMI_LOC_DELETE_CELL_DATABASE_LAST_SRV_CELL, "QMI_LOC_DELETE_CELL_DATABASE_LAST_SRV_CELL", "last-srv-cell" },
    { QMI_LOC_DELETE_CELL_DATABASE_CUR_SRV_CELL, "QMI_LOC_DELETE_CELL_DATABASE_CUR_SRV_CELL", "cur-srv-cell" },
    { QMI_LOC_DELETE_CELL_DATABASE_NEIGHBOR_INFO, "QMI_LOC_DELETE_CELL_DATABASE_NEIGHBOR_INFO", "neighbor-info" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_loc_delete_cell_database_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiLocDeleteCellDatabase"),
                                      qmi_loc_delete_cell_database_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_loc_delete_cell_database_build_string_from_mask (QmiLocDeleteCellDatabase mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_loc_delete_cell_database_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_loc_delete_cell_database_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_loc_delete_cell_database_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_loc_delete_cell_database_values[i].value) {
            guint c;
            gulong number = qmi_loc_delete_cell_database_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_loc_delete_cell_database_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_loc_delete_clock_info_values[] = {
    { QMI_LOC_DELETE_CLOCK_INFO_TIME_EST, "QMI_LOC_DELETE_CLOCK_INFO_TIME_EST", "time-est" },
    { QMI_LOC_DELETE_CLOCK_INFO_FREQ_EST, "QMI_LOC_DELETE_CLOCK_INFO_FREQ_EST", "freq-est" },
    { QMI_LOC_DELETE_CLOCK_INFO_WEEK_NUMBER, "QMI_LOC_DELETE_CLOCK_INFO_WEEK_NUMBER", "week-number" },
    { QMI_LOC_DELETE_CLOCK_INFO_RTC_TIME, "QMI_LOC_DELETE_CLOCK_INFO_RTC_TIME", "rtc-time" },
    { QMI_LOC_DELETE_CLOCK_INFO_TIME_TRANSFER, "QMI_LOC_DELETE_CLOCK_INFO_TIME_TRANSFER", "time-transfer" },
    { QMI_LOC_DELETE_CLOCK_INFO_GPS_TIME_EST, "QMI_LOC_DELETE_CLOCK_INFO_GPS_TIME_EST", "gps-time-est" },
    { QMI_LOC_DELETE_CLOCK_INFO_GLO_TIME_EST, "QMI_LOC_DELETE_CLOCK_INFO_GLO_TIME_EST", "glo-time-est" },
    { QMI_LOC_DELETE_CLOCK_INFO_GLO_DAY_NUMBER, "QMI_LOC_DELETE_CLOCK_INFO_GLO_DAY_NUMBER", "glo-day-number" },
    { QMI_LOC_DELETE_CLOCK_INFO_GLO_YEAR_NUMBER, "QMI_LOC_DELETE_CLOCK_INFO_GLO_YEAR_NUMBER", "glo-year-number" },
    { QMI_LOC_DELETE_CLOCK_INFO_GLO_RF_GRP_DELAY, "QMI_LOC_DELETE_CLOCK_INFO_GLO_RF_GRP_DELAY", "glo-rf-grp-delay" },
    { QMI_LOC_DELETE_CLOCK_INFO_DISABLE_TT, "QMI_LOC_DELETE_CLOCK_INFO_DISABLE_TT", "disable-tt" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_loc_delete_clock_info_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiLocDeleteClockInfo"),
                                      qmi_loc_delete_clock_info_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_loc_delete_clock_info_build_string_from_mask (QmiLocDeleteClockInfo mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_loc_delete_clock_info_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_loc_delete_clock_info_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_loc_delete_clock_info_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_loc_delete_clock_info_values[i].value) {
            guint c;
            gulong number = qmi_loc_delete_clock_info_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_loc_delete_clock_info_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_loc_nmea_type_values[] = {
    { QMI_LOC_NMEA_TYPE_GGA, "QMI_LOC_NMEA_TYPE_GGA", "gga" },
    { QMI_LOC_NMEA_TYPE_RMC, "QMI_LOC_NMEA_TYPE_RMC", "rmc" },
    { QMI_LOC_NMEA_TYPE_GSV, "QMI_LOC_NMEA_TYPE_GSV", "gsv" },
    { QMI_LOC_NMEA_TYPE_GSA, "QMI_LOC_NMEA_TYPE_GSA", "gsa" },
    { QMI_LOC_NMEA_TYPE_VTG, "QMI_LOC_NMEA_TYPE_VTG", "vtg" },
    { QMI_LOC_NMEA_TYPE_PQXFI, "QMI_LOC_NMEA_TYPE_PQXFI", "pqxfi" },
    { QMI_LOC_NMEA_TYPE_PSTIS, "QMI_LOC_NMEA_TYPE_PSTIS", "pstis" },
    { QMI_LOC_NMEA_TYPE_ALL, "QMI_LOC_NMEA_TYPE_ALL", "all" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_loc_nmea_type_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiLocNmeaType"),
                                      qmi_loc_nmea_type_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_loc_nmea_type_build_string_from_mask (QmiLocNmeaType mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_loc_nmea_type_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_loc_nmea_type_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_loc_nmea_type_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_loc_nmea_type_values[i].value) {
            guint c;
            gulong number = qmi_loc_nmea_type_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_loc_nmea_type_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
/* enumerations from "../git/src/libqmi-glib/qmi-enums-nas.h" */
static const GFlagsValue qmi_nas_signal_strength_request_values[] = {
    { QMI_NAS_SIGNAL_STRENGTH_REQUEST_NONE, "QMI_NAS_SIGNAL_STRENGTH_REQUEST_NONE", "none" },
    { QMI_NAS_SIGNAL_STRENGTH_REQUEST_RSSI, "QMI_NAS_SIGNAL_STRENGTH_REQUEST_RSSI", "rssi" },
    { QMI_NAS_SIGNAL_STRENGTH_REQUEST_ECIO, "QMI_NAS_SIGNAL_STRENGTH_REQUEST_ECIO", "ecio" },
    { QMI_NAS_SIGNAL_STRENGTH_REQUEST_IO, "QMI_NAS_SIGNAL_STRENGTH_REQUEST_IO", "io" },
    { QMI_NAS_SIGNAL_STRENGTH_REQUEST_SINR, "QMI_NAS_SIGNAL_STRENGTH_REQUEST_SINR", "sinr" },
    { QMI_NAS_SIGNAL_STRENGTH_REQUEST_ERROR_RATE, "QMI_NAS_SIGNAL_STRENGTH_REQUEST_ERROR_RATE", "error-rate" },
    { QMI_NAS_SIGNAL_STRENGTH_REQUEST_RSRQ, "QMI_NAS_SIGNAL_STRENGTH_REQUEST_RSRQ", "rsrq" },
    { QMI_NAS_SIGNAL_STRENGTH_REQUEST_LTE_SNR, "QMI_NAS_SIGNAL_STRENGTH_REQUEST_LTE_SNR", "lte-snr" },
    { QMI_NAS_SIGNAL_STRENGTH_REQUEST_LTE_RSRP, "QMI_NAS_SIGNAL_STRENGTH_REQUEST_LTE_RSRP", "lte-rsrp" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_nas_signal_strength_request_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiNasSignalStrengthRequest"),
                                      qmi_nas_signal_strength_request_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_nas_signal_strength_request_build_string_from_mask (QmiNasSignalStrengthRequest mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_nas_signal_strength_request_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_nas_signal_strength_request_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_nas_signal_strength_request_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_nas_signal_strength_request_values[i].value) {
            guint c;
            gulong number = qmi_nas_signal_strength_request_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_nas_signal_strength_request_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_nas_network_scan_type_values[] = {
    { QMI_NAS_NETWORK_SCAN_TYPE_GSM, "QMI_NAS_NETWORK_SCAN_TYPE_GSM", "gsm" },
    { QMI_NAS_NETWORK_SCAN_TYPE_UMTS, "QMI_NAS_NETWORK_SCAN_TYPE_UMTS", "umts" },
    { QMI_NAS_NETWORK_SCAN_TYPE_LTE, "QMI_NAS_NETWORK_SCAN_TYPE_LTE", "lte" },
    { QMI_NAS_NETWORK_SCAN_TYPE_TD_SCDMA, "QMI_NAS_NETWORK_SCAN_TYPE_TD_SCDMA", "td-scdma" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_nas_network_scan_type_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiNasNetworkScanType"),
                                      qmi_nas_network_scan_type_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_nas_network_scan_type_build_string_from_mask (QmiNasNetworkScanType mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_nas_network_scan_type_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_nas_network_scan_type_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_nas_network_scan_type_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_nas_network_scan_type_values[i].value) {
            guint c;
            gulong number = qmi_nas_network_scan_type_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_nas_network_scan_type_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_nas_network_status_values[] = {
    { QMI_NAS_NETWORK_STATUS_CURRENT_SERVING, "QMI_NAS_NETWORK_STATUS_CURRENT_SERVING", "current-serving" },
    { QMI_NAS_NETWORK_STATUS_AVAILABLE, "QMI_NAS_NETWORK_STATUS_AVAILABLE", "available" },
    { QMI_NAS_NETWORK_STATUS_HOME, "QMI_NAS_NETWORK_STATUS_HOME", "home" },
    { QMI_NAS_NETWORK_STATUS_ROAMING, "QMI_NAS_NETWORK_STATUS_ROAMING", "roaming" },
    { QMI_NAS_NETWORK_STATUS_FORBIDDEN, "QMI_NAS_NETWORK_STATUS_FORBIDDEN", "forbidden" },
    { QMI_NAS_NETWORK_STATUS_NOT_FORBIDDEN, "QMI_NAS_NETWORK_STATUS_NOT_FORBIDDEN", "not-forbidden" },
    { QMI_NAS_NETWORK_STATUS_PREFERRED, "QMI_NAS_NETWORK_STATUS_PREFERRED", "preferred" },
    { QMI_NAS_NETWORK_STATUS_NOT_PREFERRED, "QMI_NAS_NETWORK_STATUS_NOT_PREFERRED", "not-preferred" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_nas_network_status_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiNasNetworkStatus"),
                                      qmi_nas_network_status_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_nas_network_status_build_string_from_mask (QmiNasNetworkStatus mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_nas_network_status_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_nas_network_status_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_nas_network_status_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_nas_network_status_values[i].value) {
            guint c;
            gulong number = qmi_nas_network_status_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_nas_network_status_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_nas_plmn_access_technology_identifier_values[] = {
    { QMI_NAS_PLMN_ACCESS_TECHNOLOGY_IDENTIFIER_UNSPECIFIED, "QMI_NAS_PLMN_ACCESS_TECHNOLOGY_IDENTIFIER_UNSPECIFIED", "unspecified" },
    { QMI_NAS_PLMN_ACCESS_TECHNOLOGY_IDENTIFIER_GSM_COMPACT, "QMI_NAS_PLMN_ACCESS_TECHNOLOGY_IDENTIFIER_GSM_COMPACT", "gsm-compact" },
    { QMI_NAS_PLMN_ACCESS_TECHNOLOGY_IDENTIFIER_GSM, "QMI_NAS_PLMN_ACCESS_TECHNOLOGY_IDENTIFIER_GSM", "gsm" },
    { QMI_NAS_PLMN_ACCESS_TECHNOLOGY_IDENTIFIER_NGRAN, "QMI_NAS_PLMN_ACCESS_TECHNOLOGY_IDENTIFIER_NGRAN", "ngran" },
    { QMI_NAS_PLMN_ACCESS_TECHNOLOGY_IDENTIFIER_EUTRAN, "QMI_NAS_PLMN_ACCESS_TECHNOLOGY_IDENTIFIER_EUTRAN", "eutran" },
    { QMI_NAS_PLMN_ACCESS_TECHNOLOGY_IDENTIFIER_UTRAN, "QMI_NAS_PLMN_ACCESS_TECHNOLOGY_IDENTIFIER_UTRAN", "utran" },
    { QMI_NAS_PLMN_ACCESS_TECHNOLOGY_IDENTIFIER_ALL, "QMI_NAS_PLMN_ACCESS_TECHNOLOGY_IDENTIFIER_ALL", "all" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_nas_plmn_access_technology_identifier_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiNasPlmnAccessTechnologyIdentifier"),
                                      qmi_nas_plmn_access_technology_identifier_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_nas_plmn_access_technology_identifier_build_string_from_mask (QmiNasPlmnAccessTechnologyIdentifier mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_nas_plmn_access_technology_identifier_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_nas_plmn_access_technology_identifier_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_nas_plmn_access_technology_identifier_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_nas_plmn_access_technology_identifier_values[i].value) {
            guint c;
            gulong number = qmi_nas_plmn_access_technology_identifier_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_nas_plmn_access_technology_identifier_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_nas_radio_technology_preference_values[] = {
    { QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_AUTO, "QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_AUTO", "auto" },
    { QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_3GPP2, "QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_3GPP2", "3gpp2" },
    { QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_3GPP, "QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_3GPP", "3gpp" },
    { QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_AMPS_OR_GSM, "QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_AMPS_OR_GSM", "amps-or-gsm" },
    { QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_CDMA_OR_WCDMA, "QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_CDMA_OR_WCDMA", "cdma-or-wcdma" },
    { QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_HDR, "QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_HDR", "hdr" },
    { QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_LTE, "QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_LTE", "lte" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_nas_radio_technology_preference_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiNasRadioTechnologyPreference"),
                                      qmi_nas_radio_technology_preference_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_nas_radio_technology_preference_build_string_from_mask (QmiNasRadioTechnologyPreference mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_nas_radio_technology_preference_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_nas_radio_technology_preference_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_nas_radio_technology_preference_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_nas_radio_technology_preference_values[i].value) {
            guint c;
            gulong number = qmi_nas_radio_technology_preference_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_nas_radio_technology_preference_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_nas_rat_mode_preference_values[] = {
    { QMI_NAS_RAT_MODE_PREFERENCE_CDMA_1X, "QMI_NAS_RAT_MODE_PREFERENCE_CDMA_1X", "cdma-1x" },
    { QMI_NAS_RAT_MODE_PREFERENCE_CDMA_1XEVDO, "QMI_NAS_RAT_MODE_PREFERENCE_CDMA_1XEVDO", "cdma-1xevdo" },
    { QMI_NAS_RAT_MODE_PREFERENCE_GSM, "QMI_NAS_RAT_MODE_PREFERENCE_GSM", "gsm" },
    { QMI_NAS_RAT_MODE_PREFERENCE_UMTS, "QMI_NAS_RAT_MODE_PREFERENCE_UMTS", "umts" },
    { QMI_NAS_RAT_MODE_PREFERENCE_LTE, "QMI_NAS_RAT_MODE_PREFERENCE_LTE", "lte" },
    { QMI_NAS_RAT_MODE_PREFERENCE_TD_SCDMA, "QMI_NAS_RAT_MODE_PREFERENCE_TD_SCDMA", "td-scdma" },
    { QMI_NAS_RAT_MODE_PREFERENCE_5GNR, "QMI_NAS_RAT_MODE_PREFERENCE_5GNR", "5gnr" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_nas_rat_mode_preference_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiNasRatModePreference"),
                                      qmi_nas_rat_mode_preference_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_nas_rat_mode_preference_build_string_from_mask (QmiNasRatModePreference mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_nas_rat_mode_preference_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_nas_rat_mode_preference_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_nas_rat_mode_preference_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_nas_rat_mode_preference_values[i].value) {
            guint c;
            gulong number = qmi_nas_rat_mode_preference_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_nas_rat_mode_preference_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_nas_td_scdma_band_preference_values[] = {
    { QMI_NAS_TD_SCDMA_BAND_PREFERENCE_A, "QMI_NAS_TD_SCDMA_BAND_PREFERENCE_A", "a" },
    { QMI_NAS_TD_SCDMA_BAND_PREFERENCE_B, "QMI_NAS_TD_SCDMA_BAND_PREFERENCE_B", "b" },
    { QMI_NAS_TD_SCDMA_BAND_PREFERENCE_C, "QMI_NAS_TD_SCDMA_BAND_PREFERENCE_C", "c" },
    { QMI_NAS_TD_SCDMA_BAND_PREFERENCE_D, "QMI_NAS_TD_SCDMA_BAND_PREFERENCE_D", "d" },
    { QMI_NAS_TD_SCDMA_BAND_PREFERENCE_E, "QMI_NAS_TD_SCDMA_BAND_PREFERENCE_E", "e" },
    { QMI_NAS_TD_SCDMA_BAND_PREFERENCE_F, "QMI_NAS_TD_SCDMA_BAND_PREFERENCE_F", "f" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_nas_td_scdma_band_preference_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiNasTdScdmaBandPreference"),
                                      qmi_nas_td_scdma_band_preference_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_nas_td_scdma_band_preference_build_string_from_mask (QmiNasTdScdmaBandPreference mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_nas_td_scdma_band_preference_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_nas_td_scdma_band_preference_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_nas_td_scdma_band_preference_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_nas_td_scdma_band_preference_values[i].value) {
            guint c;
            gulong number = qmi_nas_td_scdma_band_preference_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_nas_td_scdma_band_preference_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_nas_network_name_display_condition_values[] = {
    { QMI_NAS_NETWORK_NAME_DISPLAY_CONDITION_DISPLAY_REGISTERED_PLMN_IF_KNOWN_NETWORK, "QMI_NAS_NETWORK_NAME_DISPLAY_CONDITION_DISPLAY_REGISTERED_PLMN_IF_KNOWN_NETWORK", "registered-plmn-if-known-network" },
    { QMI_NAS_NETWORK_NAME_DISPLAY_CONDITION_DISPLAY_SPN_NOT_REQUIRED_IF_UNKNOWN_NETWORK, "QMI_NAS_NETWORK_NAME_DISPLAY_CONDITION_DISPLAY_SPN_NOT_REQUIRED_IF_UNKNOWN_NETWORK", "spn-not-required-if-unknown-network" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_nas_network_name_display_condition_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiNasNetworkNameDisplayCondition"),
                                      qmi_nas_network_name_display_condition_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_nas_network_name_display_condition_build_string_from_mask (QmiNasNetworkNameDisplayCondition mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_nas_network_name_display_condition_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_nas_network_name_display_condition_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_nas_network_name_display_condition_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_nas_network_name_display_condition_values[i].value) {
            guint c;
            gulong number = qmi_nas_network_name_display_condition_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_nas_network_name_display_condition_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
/* enumerations from "../git/src/libqmi-glib/qmi-enums-pbm.h" */
static const GFlagsValue qmi_pbm_event_registration_flag_values[] = {
    { QMI_PBM_EVENT_REGISTRATION_FLAG_RECORD_UPDATE, "QMI_PBM_EVENT_REGISTRATION_FLAG_RECORD_UPDATE", "record-update" },
    { QMI_PBM_EVENT_REGISTRATION_FLAG_PHONEBOOK_READY, "QMI_PBM_EVENT_REGISTRATION_FLAG_PHONEBOOK_READY", "phonebook-ready" },
    { QMI_PBM_EVENT_REGISTRATION_FLAG_EMERGENCY_NUMBER_LIST, "QMI_PBM_EVENT_REGISTRATION_FLAG_EMERGENCY_NUMBER_LIST", "emergency-number-list" },
    { QMI_PBM_EVENT_REGISTRATION_FLAG_HIDDEN_RECORD_STATUS, "QMI_PBM_EVENT_REGISTRATION_FLAG_HIDDEN_RECORD_STATUS", "hidden-record-status" },
    { QMI_PBM_EVENT_REGISTRATION_FLAG_AAS_UPDATE, "QMI_PBM_EVENT_REGISTRATION_FLAG_AAS_UPDATE", "aas-update" },
    { QMI_PBM_EVENT_REGISTRATION_FLAG_GAS_UPDATE, "QMI_PBM_EVENT_REGISTRATION_FLAG_GAS_UPDATE", "gas-update" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_pbm_event_registration_flag_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiPbmEventRegistrationFlag"),
                                      qmi_pbm_event_registration_flag_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_pbm_event_registration_flag_build_string_from_mask (QmiPbmEventRegistrationFlag mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_pbm_event_registration_flag_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_pbm_event_registration_flag_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_pbm_event_registration_flag_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_pbm_event_registration_flag_values[i].value) {
            guint c;
            gulong number = qmi_pbm_event_registration_flag_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_pbm_event_registration_flag_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_pbm_phonebook_type_values[] = {
    { QMI_PBM_PHONEBOOK_TYPE_ADN, "QMI_PBM_PHONEBOOK_TYPE_ADN", "adn" },
    { QMI_PBM_PHONEBOOK_TYPE_FDN, "QMI_PBM_PHONEBOOK_TYPE_FDN", "fdn" },
    { QMI_PBM_PHONEBOOK_TYPE_MSISDN, "QMI_PBM_PHONEBOOK_TYPE_MSISDN", "msisdn" },
    { QMI_PBM_PHONEBOOK_TYPE_MBDN, "QMI_PBM_PHONEBOOK_TYPE_MBDN", "mbdn" },
    { QMI_PBM_PHONEBOOK_TYPE_SDN, "QMI_PBM_PHONEBOOK_TYPE_SDN", "sdn" },
    { QMI_PBM_PHONEBOOK_TYPE_BDN, "QMI_PBM_PHONEBOOK_TYPE_BDN", "bdn" },
    { QMI_PBM_PHONEBOOK_TYPE_LND, "QMI_PBM_PHONEBOOK_TYPE_LND", "lnd" },
    { QMI_PBM_PHONEBOOK_TYPE_MBN, "QMI_PBM_PHONEBOOK_TYPE_MBN", "mbn" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_pbm_phonebook_type_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiPbmPhonebookType"),
                                      qmi_pbm_phonebook_type_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_pbm_phonebook_type_build_string_from_mask (QmiPbmPhonebookType mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_pbm_phonebook_type_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_pbm_phonebook_type_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_pbm_phonebook_type_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_pbm_phonebook_type_values[i].value) {
            guint c;
            gulong number = qmi_pbm_phonebook_type_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_pbm_phonebook_type_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
/* enumerations from "../git/src/libqmi-glib/qmi-enums-pds.h" */
static const GFlagsValue qmi_pds_data_valid_values[] = {
    { QMI_PDS_DATA_VALID_TIMESTAMP_CALENDAR, "QMI_PDS_DATA_VALID_TIMESTAMP_CALENDAR", "timestamp-calendar" },
    { QMI_PDS_DATA_VALID_TIMESTAMP_UTC, "QMI_PDS_DATA_VALID_TIMESTAMP_UTC", "timestamp-utc" },
    { QMI_PDS_DATA_VALID_LEAP_SECONDS, "QMI_PDS_DATA_VALID_LEAP_SECONDS", "leap-seconds" },
    { QMI_PDS_DATA_VALID_TIME_UNCERTAINTY, "QMI_PDS_DATA_VALID_TIME_UNCERTAINTY", "time-uncertainty" },
    { QMI_PDS_DATA_VALID_LATITUDE, "QMI_PDS_DATA_VALID_LATITUDE", "latitude" },
    { QMI_PDS_DATA_VALID_LONGITUDE, "QMI_PDS_DATA_VALID_LONGITUDE", "longitude" },
    { QMI_PDS_DATA_VALID_ELLIPSOID_ALTITUDE, "QMI_PDS_DATA_VALID_ELLIPSOID_ALTITUDE", "ellipsoid-altitude" },
    { QMI_PDS_DATA_VALID_MEAN_SEA_LEVEL_ALTITUDE, "QMI_PDS_DATA_VALID_MEAN_SEA_LEVEL_ALTITUDE", "mean-sea-level-altitude" },
    { QMI_PDS_DATA_VALID_HORIZONTAL_SPEED, "QMI_PDS_DATA_VALID_HORIZONTAL_SPEED", "horizontal-speed" },
    { QMI_PDS_DATA_VALID_VERTICAL_SPEED, "QMI_PDS_DATA_VALID_VERTICAL_SPEED", "vertical-speed" },
    { QMI_PDS_DATA_VALID_HEADING, "QMI_PDS_DATA_VALID_HEADING", "heading" },
    { QMI_PDS_DATA_VALID_HORIZONTAL_UNCERTAINTY_CIRCULAR, "QMI_PDS_DATA_VALID_HORIZONTAL_UNCERTAINTY_CIRCULAR", "horizontal-uncertainty-circular" },
    { QMI_PDS_DATA_VALID_HORIZONTAL_UNCERTAINTY_ELLIPSE_SEMI_MAJOR, "QMI_PDS_DATA_VALID_HORIZONTAL_UNCERTAINTY_ELLIPSE_SEMI_MAJOR", "horizontal-uncertainty-ellipse-semi-major" },
    { QMI_PDS_DATA_VALID_HORIZONTAL_UNCERTAINTY_ELLIPSE_SEMI_MINOR, "QMI_PDS_DATA_VALID_HORIZONTAL_UNCERTAINTY_ELLIPSE_SEMI_MINOR", "horizontal-uncertainty-ellipse-semi-minor" },
    { QMI_PDS_DATA_VALID_HORIZONTAL_UNCERTAINTY_ELLIPSE_ORIENT_AZIMUTH, "QMI_PDS_DATA_VALID_HORIZONTAL_UNCERTAINTY_ELLIPSE_ORIENT_AZIMUTH", "horizontal-uncertainty-ellipse-orient-azimuth" },
    { QMI_PDS_DATA_VALID_VERTICAL_UNCERTAINTY, "QMI_PDS_DATA_VALID_VERTICAL_UNCERTAINTY", "vertical-uncertainty" },
    { QMI_PDS_DATA_VALID_HORIZONTAL_VELOCITY_UNCERTAINTY, "QMI_PDS_DATA_VALID_HORIZONTAL_VELOCITY_UNCERTAINTY", "horizontal-velocity-uncertainty" },
    { QMI_PDS_DATA_VALID_VERTICAL_VELOCITY_UNCERTAINTY, "QMI_PDS_DATA_VALID_VERTICAL_VELOCITY_UNCERTAINTY", "vertical-velocity-uncertainty" },
    { QMI_PDS_DATA_VALID_HORIZONTAL_CONFIDENCE, "QMI_PDS_DATA_VALID_HORIZONTAL_CONFIDENCE", "horizontal-confidence" },
    { QMI_PDS_DATA_VALID_POSITION_DOP, "QMI_PDS_DATA_VALID_POSITION_DOP", "position-dop" },
    { QMI_PDS_DATA_VALID_HORIZONTAL_DOP, "QMI_PDS_DATA_VALID_HORIZONTAL_DOP", "horizontal-dop" },
    { QMI_PDS_DATA_VALID_VERTICAL_DOP, "QMI_PDS_DATA_VALID_VERTICAL_DOP", "vertical-dop" },
    { QMI_PDS_DATA_VALID_OPERATING_MODE, "QMI_PDS_DATA_VALID_OPERATING_MODE", "operating-mode" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_pds_data_valid_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiPdsDataValid"),
                                      qmi_pds_data_valid_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_pds_data_valid_build_string_from_mask (QmiPdsDataValid mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_pds_data_valid_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_pds_data_valid_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_pds_data_valid_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_pds_data_valid_values[i].value) {
            guint c;
            gulong number = qmi_pds_data_valid_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_pds_data_valid_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
/* enumerations from "../git/src/libqmi-glib/qmi-enums-uim.h" */
static const GFlagsValue qmi_uim_event_registration_flag_values[] = {
    { QMI_UIM_EVENT_REGISTRATION_FLAG_CARD_STATUS, "QMI_UIM_EVENT_REGISTRATION_FLAG_CARD_STATUS", "card-status" },
    { QMI_UIM_EVENT_REGISTRATION_FLAG_SAP_CONNECTION, "QMI_UIM_EVENT_REGISTRATION_FLAG_SAP_CONNECTION", "sap-connection" },
    { QMI_UIM_EVENT_REGISTRATION_FLAG_EXTENDED_CARD_STATUS, "QMI_UIM_EVENT_REGISTRATION_FLAG_EXTENDED_CARD_STATUS", "extended-card-status" },
    { QMI_UIM_EVENT_REGISTRATION_FLAG_PHYSICAL_SLOT_STATUS, "QMI_UIM_EVENT_REGISTRATION_FLAG_PHYSICAL_SLOT_STATUS", "physical-slot-status" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_uim_event_registration_flag_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiUimEventRegistrationFlag"),
                                      qmi_uim_event_registration_flag_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_uim_event_registration_flag_build_string_from_mask (QmiUimEventRegistrationFlag mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_uim_event_registration_flag_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_uim_event_registration_flag_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_uim_event_registration_flag_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_uim_event_registration_flag_values[i].value) {
            guint c;
            gulong number = qmi_uim_event_registration_flag_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_uim_event_registration_flag_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_uim_security_attribute_values[] = {
    { QMI_UIM_SECURITY_ATTRIBUTE_PIN1, "QMI_UIM_SECURITY_ATTRIBUTE_PIN1", "pin1" },
    { QMI_UIM_SECURITY_ATTRIBUTE_PIN2, "QMI_UIM_SECURITY_ATTRIBUTE_PIN2", "pin2" },
    { QMI_UIM_SECURITY_ATTRIBUTE_UPIN, "QMI_UIM_SECURITY_ATTRIBUTE_UPIN", "upin" },
    { QMI_UIM_SECURITY_ATTRIBUTE_ADM, "QMI_UIM_SECURITY_ATTRIBUTE_ADM", "adm" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_uim_security_attribute_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiUimSecurityAttribute"),
                                      qmi_uim_security_attribute_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_uim_security_attribute_build_string_from_mask (QmiUimSecurityAttribute mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_uim_security_attribute_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_uim_security_attribute_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_uim_security_attribute_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_uim_security_attribute_values[i].value) {
            guint c;
            gulong number = qmi_uim_security_attribute_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_uim_security_attribute_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_uim_configuration_values[] = {
    { QMI_UIM_CONFIGURATION_AUTOMATIC_SELECTION, "QMI_UIM_CONFIGURATION_AUTOMATIC_SELECTION", "automatic-selection" },
    { QMI_UIM_CONFIGURATION_PERSONALIZATION_STATUS, "QMI_UIM_CONFIGURATION_PERSONALIZATION_STATUS", "personalization-status" },
    { QMI_UIM_CONFIGURATION_HALT_SUBSCRIPTION, "QMI_UIM_CONFIGURATION_HALT_SUBSCRIPTION", "halt-subscription" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_uim_configuration_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiUimConfiguration"),
                                      qmi_uim_configuration_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_uim_configuration_build_string_from_mask (QmiUimConfiguration mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_uim_configuration_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_uim_configuration_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_uim_configuration_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_uim_configuration_values[i].value) {
            guint c;
            gulong number = qmi_uim_configuration_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_uim_configuration_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
/* enumerations from "../git/src/libqmi-glib/qmi-enums-voice.h" */
static const GFlagsValue qmi_voice_wcdma_amr_status_values[] = {
    { QMI_VOICE_WCDMA_AMR_STATUS_NOT_SUPPORTED, "QMI_VOICE_WCDMA_AMR_STATUS_NOT_SUPPORTED", "not-supported" },
    { QMI_VOICE_WCDMA_AMR_STATUS_WCDMA_AMR_WB, "QMI_VOICE_WCDMA_AMR_STATUS_WCDMA_AMR_WB", "wcdma-amr-wb" },
    { QMI_VOICE_WCDMA_AMR_STATUS_GSM_HR_AMR, "QMI_VOICE_WCDMA_AMR_STATUS_GSM_HR_AMR", "gsm-hr-amr" },
    { QMI_VOICE_WCDMA_AMR_STATUS_GSM_AMR_WB, "QMI_VOICE_WCDMA_AMR_STATUS_GSM_AMR_WB", "gsm-amr-wb" },
    { QMI_VOICE_WCDMA_AMR_STATUS_GSM_AMR_NB, "QMI_VOICE_WCDMA_AMR_STATUS_GSM_AMR_NB", "gsm-amr-nb" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_voice_wcdma_amr_status_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiVoiceWcdmaAmrStatus"),
                                      qmi_voice_wcdma_amr_status_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_voice_wcdma_amr_status_build_string_from_mask (QmiVoiceWcdmaAmrStatus mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_voice_wcdma_amr_status_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_voice_wcdma_amr_status_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_voice_wcdma_amr_status_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_voice_wcdma_amr_status_values[i].value) {
            guint c;
            gulong number = qmi_voice_wcdma_amr_status_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_voice_wcdma_amr_status_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
/* enumerations from "../git/src/libqmi-glib/qmi-enums-wds.h" */
static const GFlagsValue qmi_wds_technology_preference_values[] = {
    { QMI_WDS_TECHNOLOGY_PREFERENCE_ALLOW_3GPP, "QMI_WDS_TECHNOLOGY_PREFERENCE_ALLOW_3GPP", "3gpp" },
    { QMI_WDS_TECHNOLOGY_PREFERENCE_ALLOW_3GPP2, "QMI_WDS_TECHNOLOGY_PREFERENCE_ALLOW_3GPP2", "3gpp2" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_wds_technology_preference_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiWdsTechnologyPreference"),
                                      qmi_wds_technology_preference_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_wds_technology_preference_build_string_from_mask (QmiWdsTechnologyPreference mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_wds_technology_preference_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_wds_technology_preference_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_wds_technology_preference_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_wds_technology_preference_values[i].value) {
            guint c;
            gulong number = qmi_wds_technology_preference_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_wds_technology_preference_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_wds_rat_3gpp2_values[] = {
    { QMI_WDS_RAT_3GPP2_NONE, "QMI_WDS_RAT_3GPP2_NONE", "none" },
    { QMI_WDS_RAT_3GPP2_CDMA1X, "QMI_WDS_RAT_3GPP2_CDMA1X", "cdma1x" },
    { QMI_WDS_RAT_3GPP2_EVDO_REV0, "QMI_WDS_RAT_3GPP2_EVDO_REV0", "evdo-rev0" },
    { QMI_WDS_RAT_3GPP2_EVDO_REVA, "QMI_WDS_RAT_3GPP2_EVDO_REVA", "evdo-reva" },
    { QMI_WDS_RAT_3GPP2_EVDO_REVB, "QMI_WDS_RAT_3GPP2_EVDO_REVB", "evdo-revb" },
    { QMI_WDS_RAT_3GPP2_EHRPD, "QMI_WDS_RAT_3GPP2_EHRPD", "ehrpd" },
    { QMI_WDS_RAT_3GPP2_FMC, "QMI_WDS_RAT_3GPP2_FMC", "fmc" },
    { QMI_WDS_RAT_3GPP2_NULL_BEARER, "QMI_WDS_RAT_3GPP2_NULL_BEARER", "null-bearer" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_wds_rat_3gpp2_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiWdsRat3gpp2"),
                                      qmi_wds_rat_3gpp2_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_wds_rat_3gpp2_build_string_from_mask (QmiWdsRat3gpp2 mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_wds_rat_3gpp2_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_wds_rat_3gpp2_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_wds_rat_3gpp2_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_wds_rat_3gpp2_values[i].value) {
            guint c;
            gulong number = qmi_wds_rat_3gpp2_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_wds_rat_3gpp2_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_wds_rat_3gpp_values[] = {
    { QMI_WDS_RAT_3GPP_NONE, "QMI_WDS_RAT_3GPP_NONE", "none" },
    { QMI_WDS_RAT_3GPP_WCDMA, "QMI_WDS_RAT_3GPP_WCDMA", "wcdma" },
    { QMI_WDS_RAT_3GPP_GPRS, "QMI_WDS_RAT_3GPP_GPRS", "gprs" },
    { QMI_WDS_RAT_3GPP_HSDPA, "QMI_WDS_RAT_3GPP_HSDPA", "hsdpa" },
    { QMI_WDS_RAT_3GPP_HSUPA, "QMI_WDS_RAT_3GPP_HSUPA", "hsupa" },
    { QMI_WDS_RAT_3GPP_EDGE, "QMI_WDS_RAT_3GPP_EDGE", "edge" },
    { QMI_WDS_RAT_3GPP_LTE, "QMI_WDS_RAT_3GPP_LTE", "lte" },
    { QMI_WDS_RAT_3GPP_HSDPAPLUS, "QMI_WDS_RAT_3GPP_HSDPAPLUS", "hsdpaplus" },
    { QMI_WDS_RAT_3GPP_DCHSDPAPLUS, "QMI_WDS_RAT_3GPP_DCHSDPAPLUS", "dchsdpaplus" },
    { QMI_WDS_RAT_3GPP_64QAM, "QMI_WDS_RAT_3GPP_64QAM", "64qam" },
    { QMI_WDS_RAT_3GPP_TDSCDMA, "QMI_WDS_RAT_3GPP_TDSCDMA", "tdscdma" },
    { QMI_WDS_RAT_3GPP_NULL_BEARER, "QMI_WDS_RAT_3GPP_NULL_BEARER", "null-bearer" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_wds_rat_3gpp_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiWdsRat3gpp"),
                                      qmi_wds_rat_3gpp_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_wds_rat_3gpp_build_string_from_mask (QmiWdsRat3gpp mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_wds_rat_3gpp_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_wds_rat_3gpp_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_wds_rat_3gpp_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_wds_rat_3gpp_values[i].value) {
            guint c;
            gulong number = qmi_wds_rat_3gpp_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_wds_rat_3gpp_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_wds_so_cdma1x_values[] = {
    { QMI_WDS_SO_CDMA1X_NONE, "QMI_WDS_SO_CDMA1X_NONE", "none" },
    { QMI_WDS_SO_CDMA1X_IS95, "QMI_WDS_SO_CDMA1X_IS95", "is95" },
    { QMI_WDS_SO_CDMA1X_IS2000, "QMI_WDS_SO_CDMA1X_IS2000", "is2000" },
    { QMI_WDS_SO_CDMA1X_IS2000_REL_A, "QMI_WDS_SO_CDMA1X_IS2000_REL_A", "is2000-rel-a" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_wds_so_cdma1x_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiWdsSoCdma1x"),
                                      qmi_wds_so_cdma1x_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_wds_so_cdma1x_build_string_from_mask (QmiWdsSoCdma1x mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_wds_so_cdma1x_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_wds_so_cdma1x_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_wds_so_cdma1x_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_wds_so_cdma1x_values[i].value) {
            guint c;
            gulong number = qmi_wds_so_cdma1x_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_wds_so_cdma1x_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_wds_so_evdo_rev0_values[] = {
    { QMI_WDS_SO_EVDO_REV0_NONE, "QMI_WDS_SO_EVDO_REV0_NONE", "none" },
    { QMI_WDS_SO_EVDO_REV0_DPA, "QMI_WDS_SO_EVDO_REV0_DPA", "dpa" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_wds_so_evdo_rev0_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiWdsSoEvdoRev0"),
                                      qmi_wds_so_evdo_rev0_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_wds_so_evdo_rev0_build_string_from_mask (QmiWdsSoEvdoRev0 mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_wds_so_evdo_rev0_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_wds_so_evdo_rev0_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_wds_so_evdo_rev0_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_wds_so_evdo_rev0_values[i].value) {
            guint c;
            gulong number = qmi_wds_so_evdo_rev0_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_wds_so_evdo_rev0_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_wds_so_evdo_reva_values[] = {
    { QMI_WDS_SO_EVDO_REVA_NONE, "QMI_WDS_SO_EVDO_REVA_NONE", "none" },
    { QMI_WDS_SO_EVDO_REVA_DPA, "QMI_WDS_SO_EVDO_REVA_DPA", "dpa" },
    { QMI_WDS_SO_EVDO_REVA_MFPA, "QMI_WDS_SO_EVDO_REVA_MFPA", "mfpa" },
    { QMI_WDS_SO_EVDO_REVA_EMPA, "QMI_WDS_SO_EVDO_REVA_EMPA", "empa" },
    { QMI_WDS_SO_EVDO_REVA_EMPA_EHRPD, "QMI_WDS_SO_EVDO_REVA_EMPA_EHRPD", "empa-ehrpd" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_wds_so_evdo_reva_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiWdsSoEvdoRevA"),
                                      qmi_wds_so_evdo_reva_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_wds_so_evdo_reva_build_string_from_mask (QmiWdsSoEvdoRevA mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_wds_so_evdo_reva_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_wds_so_evdo_reva_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_wds_so_evdo_reva_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_wds_so_evdo_reva_values[i].value) {
            guint c;
            gulong number = qmi_wds_so_evdo_reva_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_wds_so_evdo_reva_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_wds_so_evdo_revb_values[] = {
    { QMI_WDS_SO_EVDO_REVB_NONE, "QMI_WDS_SO_EVDO_REVB_NONE", "none" },
    { QMI_WDS_SO_EVDO_REVB_DPA, "QMI_WDS_SO_EVDO_REVB_DPA", "dpa" },
    { QMI_WDS_SO_EVDO_REVB_MFPA, "QMI_WDS_SO_EVDO_REVB_MFPA", "mfpa" },
    { QMI_WDS_SO_EVDO_REVB_EMPA, "QMI_WDS_SO_EVDO_REVB_EMPA", "empa" },
    { QMI_WDS_SO_EVDO_REVB_EMPA_EHRPD, "QMI_WDS_SO_EVDO_REVB_EMPA_EHRPD", "empa-ehrpd" },
    { QMI_WDS_SO_EVDO_REVB_MMPA, "QMI_WDS_SO_EVDO_REVB_MMPA", "mmpa" },
    { QMI_WDS_SO_EVDO_REVB_MMPA_EHRPD, "QMI_WDS_SO_EVDO_REVB_MMPA_EHRPD", "mmpa-ehrpd" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_wds_so_evdo_revb_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiWdsSoEvdoRevB"),
                                      qmi_wds_so_evdo_revb_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_wds_so_evdo_revb_build_string_from_mask (QmiWdsSoEvdoRevB mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_wds_so_evdo_revb_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_wds_so_evdo_revb_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_wds_so_evdo_revb_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_wds_so_evdo_revb_values[i].value) {
            guint c;
            gulong number = qmi_wds_so_evdo_revb_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_wds_so_evdo_revb_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_wds_requested_settings_values[] = {
    { QMI_WDS_REQUESTED_SETTINGS_NONE, "QMI_WDS_REQUESTED_SETTINGS_NONE", "none" },
    { QMI_WDS_REQUESTED_SETTINGS_PROFILE_ID, "QMI_WDS_REQUESTED_SETTINGS_PROFILE_ID", "profile-id" },
    { QMI_WDS_REQUESTED_SETTINGS_PROFILE_NAME, "QMI_WDS_REQUESTED_SETTINGS_PROFILE_NAME", "profile-name" },
    { QMI_WDS_REQUESTED_SETTINGS_PDP_TYPE, "QMI_WDS_REQUESTED_SETTINGS_PDP_TYPE", "pdp-type" },
    { QMI_WDS_REQUESTED_SETTINGS_APN_NAME, "QMI_WDS_REQUESTED_SETTINGS_APN_NAME", "apn-name" },
    { QMI_WDS_REQUESTED_SETTINGS_DNS_ADDRESS, "QMI_WDS_REQUESTED_SETTINGS_DNS_ADDRESS", "dns-address" },
    { QMI_WDS_REQUESTED_SETTINGS_GRANTED_QOS, "QMI_WDS_REQUESTED_SETTINGS_GRANTED_QOS", "granted-qos" },
    { QMI_WDS_REQUESTED_SETTINGS_USERNAME, "QMI_WDS_REQUESTED_SETTINGS_USERNAME", "username" },
    { QMI_WDS_REQUESTED_SETTINGS_AUTH_PROTOCOL, "QMI_WDS_REQUESTED_SETTINGS_AUTH_PROTOCOL", "auth-protocol" },
    { QMI_WDS_REQUESTED_SETTINGS_IP_ADDRESS, "QMI_WDS_REQUESTED_SETTINGS_IP_ADDRESS", "ip-address" },
    { QMI_WDS_REQUESTED_SETTINGS_GATEWAY_INFO, "QMI_WDS_REQUESTED_SETTINGS_GATEWAY_INFO", "gateway-info" },
    { QMI_WDS_REQUESTED_SETTINGS_PCSCF_ADDRESS, "QMI_WDS_REQUESTED_SETTINGS_PCSCF_ADDRESS", "pcscf-address" },
    { QMI_WDS_REQUESTED_SETTINGS_PCSCF_SERVER_ADDRESS_LIST, "QMI_WDS_REQUESTED_SETTINGS_PCSCF_SERVER_ADDRESS_LIST", "pcscf-server-address-list" },
    { QMI_WDS_REQUESTED_SETTINGS_PCSCF_DOMAIN_NAME_LIST, "QMI_WDS_REQUESTED_SETTINGS_PCSCF_DOMAIN_NAME_LIST", "pcscf-domain-name-list" },
    { QMI_WDS_REQUESTED_SETTINGS_MTU, "QMI_WDS_REQUESTED_SETTINGS_MTU", "mtu" },
    { QMI_WDS_REQUESTED_SETTINGS_DOMAIN_NAME_LIST, "QMI_WDS_REQUESTED_SETTINGS_DOMAIN_NAME_LIST", "domain-name-list" },
    { QMI_WDS_REQUESTED_SETTINGS_IP_FAMILY, "QMI_WDS_REQUESTED_SETTINGS_IP_FAMILY", "ip-family" },
    { QMI_WDS_REQUESTED_SETTINGS_IMCN_FLAG, "QMI_WDS_REQUESTED_SETTINGS_IMCN_FLAG", "imcn-flag" },
    { QMI_WDS_REQUESTED_SETTINGS_EXTENDED_TECHNOLOGY, "QMI_WDS_REQUESTED_SETTINGS_EXTENDED_TECHNOLOGY", "extended-technology" },
    { QMI_WDS_REQUESTED_SETTINGS_OPERATOR_RESERVED_PCO, "QMI_WDS_REQUESTED_SETTINGS_OPERATOR_RESERVED_PCO", "operator-reserved-pco" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_wds_requested_settings_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiWdsRequestedSettings"),
                                      qmi_wds_requested_settings_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_wds_requested_settings_build_string_from_mask (QmiWdsRequestedSettings mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_wds_requested_settings_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_wds_requested_settings_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_wds_requested_settings_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_wds_requested_settings_values[i].value) {
            guint c;
            gulong number = qmi_wds_requested_settings_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_wds_requested_settings_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_wds_authentication_values[] = {
    { QMI_WDS_AUTHENTICATION_NONE, "QMI_WDS_AUTHENTICATION_NONE", "none" },
    { QMI_WDS_AUTHENTICATION_PAP, "QMI_WDS_AUTHENTICATION_PAP", "pap" },
    { QMI_WDS_AUTHENTICATION_CHAP, "QMI_WDS_AUTHENTICATION_CHAP", "chap" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_wds_authentication_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiWdsAuthentication"),
                                      qmi_wds_authentication_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_wds_authentication_build_string_from_mask (QmiWdsAuthentication mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_wds_authentication_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_wds_authentication_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_wds_authentication_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_wds_authentication_values[i].value) {
            guint c;
            gulong number = qmi_wds_authentication_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_wds_authentication_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_wds_packet_statistics_mask_flag_values[] = {
    { QMI_WDS_PACKET_STATISTICS_MASK_FLAG_TX_PACKETS_OK, "QMI_WDS_PACKET_STATISTICS_MASK_FLAG_TX_PACKETS_OK", "tx-packets-ok" },
    { QMI_WDS_PACKET_STATISTICS_MASK_FLAG_RX_PACKETS_OK, "QMI_WDS_PACKET_STATISTICS_MASK_FLAG_RX_PACKETS_OK", "rx-packets-ok" },
    { QMI_WDS_PACKET_STATISTICS_MASK_FLAG_TX_PACKETS_ERROR, "QMI_WDS_PACKET_STATISTICS_MASK_FLAG_TX_PACKETS_ERROR", "tx-packets-error" },
    { QMI_WDS_PACKET_STATISTICS_MASK_FLAG_RX_PACKETS_ERROR, "QMI_WDS_PACKET_STATISTICS_MASK_FLAG_RX_PACKETS_ERROR", "rx-packets-error" },
    { QMI_WDS_PACKET_STATISTICS_MASK_FLAG_TX_OVERFLOWS, "QMI_WDS_PACKET_STATISTICS_MASK_FLAG_TX_OVERFLOWS", "tx-overflows" },
    { QMI_WDS_PACKET_STATISTICS_MASK_FLAG_RX_OVERFLOWS, "QMI_WDS_PACKET_STATISTICS_MASK_FLAG_RX_OVERFLOWS", "rx-overflows" },
    { QMI_WDS_PACKET_STATISTICS_MASK_FLAG_TX_BYTES_OK, "QMI_WDS_PACKET_STATISTICS_MASK_FLAG_TX_BYTES_OK", "tx-bytes-ok" },
    { QMI_WDS_PACKET_STATISTICS_MASK_FLAG_RX_BYTES_OK, "QMI_WDS_PACKET_STATISTICS_MASK_FLAG_RX_BYTES_OK", "rx-bytes-ok" },
    { QMI_WDS_PACKET_STATISTICS_MASK_FLAG_TX_PACKETS_DROPPED, "QMI_WDS_PACKET_STATISTICS_MASK_FLAG_TX_PACKETS_DROPPED", "tx-packets-dropped" },
    { QMI_WDS_PACKET_STATISTICS_MASK_FLAG_RX_PACKETS_DROPPED, "QMI_WDS_PACKET_STATISTICS_MASK_FLAG_RX_PACKETS_DROPPED", "rx-packets-dropped" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_wds_packet_statistics_mask_flag_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiWdsPacketStatisticsMaskFlag"),
                                      qmi_wds_packet_statistics_mask_flag_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_wds_packet_statistics_mask_flag_build_string_from_mask (QmiWdsPacketStatisticsMaskFlag mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_wds_packet_statistics_mask_flag_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_wds_packet_statistics_mask_flag_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_wds_packet_statistics_mask_flag_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_wds_packet_statistics_mask_flag_values[i].value) {
            guint c;
            gulong number = qmi_wds_packet_statistics_mask_flag_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_wds_packet_statistics_mask_flag_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_wds_set_event_report_transfer_statistics_values[] = {
    { QMI_WDS_SET_EVENT_REPORT_TRANSFER_STATISTICS_REPORT_TX_PACKETS_OK, "QMI_WDS_SET_EVENT_REPORT_TRANSFER_STATISTICS_REPORT_TX_PACKETS_OK", "tx-packets-ok" },
    { QMI_WDS_SET_EVENT_REPORT_TRANSFER_STATISTICS_REPORT_RX_PACKETS_OK, "QMI_WDS_SET_EVENT_REPORT_TRANSFER_STATISTICS_REPORT_RX_PACKETS_OK", "rx-packets-ok" },
    { QMI_WDS_SET_EVENT_REPORT_TRANSFER_STATISTICS_REPORT_TX_PACKETS_ERROR, "QMI_WDS_SET_EVENT_REPORT_TRANSFER_STATISTICS_REPORT_TX_PACKETS_ERROR", "tx-packets-error" },
    { QMI_WDS_SET_EVENT_REPORT_TRANSFER_STATISTICS_REPORT_RX_PACKETS_ERROR, "QMI_WDS_SET_EVENT_REPORT_TRANSFER_STATISTICS_REPORT_RX_PACKETS_ERROR", "rx-packets-error" },
    { QMI_WDS_SET_EVENT_REPORT_TRANSFER_STATISTICS_REPORT_TX_OVERFLOWS, "QMI_WDS_SET_EVENT_REPORT_TRANSFER_STATISTICS_REPORT_TX_OVERFLOWS", "tx-overflows" },
    { QMI_WDS_SET_EVENT_REPORT_TRANSFER_STATISTICS_REPORT_RX_OVERFLOWS, "QMI_WDS_SET_EVENT_REPORT_TRANSFER_STATISTICS_REPORT_RX_OVERFLOWS", "rx-overflows" },
    { QMI_WDS_SET_EVENT_REPORT_TRANSFER_STATISTICS_REPORT_TX_BYTES_OK, "QMI_WDS_SET_EVENT_REPORT_TRANSFER_STATISTICS_REPORT_TX_BYTES_OK", "tx-bytes-ok" },
    { QMI_WDS_SET_EVENT_REPORT_TRANSFER_STATISTICS_REPORT_RX_BYTES_OK, "QMI_WDS_SET_EVENT_REPORT_TRANSFER_STATISTICS_REPORT_RX_BYTES_OK", "rx-bytes-ok" },
    { QMI_WDS_SET_EVENT_REPORT_TRANSFER_STATISTICS_REPORT_TX_PACKETS_DROPPED, "QMI_WDS_SET_EVENT_REPORT_TRANSFER_STATISTICS_REPORT_TX_PACKETS_DROPPED", "tx-packets-dropped" },
    { QMI_WDS_SET_EVENT_REPORT_TRANSFER_STATISTICS_REPORT_RX_PACKETS_DROPPED, "QMI_WDS_SET_EVENT_REPORT_TRANSFER_STATISTICS_REPORT_RX_PACKETS_DROPPED", "rx-packets-dropped" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_wds_set_event_report_transfer_statistics_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiWdsSetEventReportTransferStatistics"),
                                      qmi_wds_set_event_report_transfer_statistics_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_wds_set_event_report_transfer_statistics_build_string_from_mask (QmiWdsSetEventReportTransferStatistics mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_wds_set_event_report_transfer_statistics_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_wds_set_event_report_transfer_statistics_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_wds_set_event_report_transfer_statistics_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_wds_set_event_report_transfer_statistics_values[i].value) {
            guint c;
            gulong number = qmi_wds_set_event_report_transfer_statistics_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_wds_set_event_report_transfer_statistics_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_wds_extended_data_bearer_technology_3gpp_values[] = {
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_UNKNOWN, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_UNKNOWN", "unknown" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_WCDMA, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_WCDMA", "wcdma" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_HSDPA, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_HSDPA", "hsdpa" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_HSUPA, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_HSUPA", "hsupa" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_HSDPA_PLUS, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_HSDPA_PLUS", "hsdpa-plus" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_DC_HSDPA_PLUS, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_DC_HSDPA_PLUS", "dc-hsdpa-plus" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_64QAM, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_64QAM", "64qam" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_HSPA, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_HSPA", "hspa" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_GPRS, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_GPRS", "gprs" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_EDGE, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_EDGE", "edge" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_GSM, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_GSM", "gsm" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_S2B, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_S2B", "s2b" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_LTE_LIMITED_SERVICE, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_LTE_LIMITED_SERVICE", "lte-limited-service" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_LTE_FDD, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_LTE_FDD", "lte-fdd" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_LTE_TDD, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP_LTE_TDD", "lte-tdd" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_wds_extended_data_bearer_technology_3gpp_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiWdsExtendedDataBearerTechnology3gpp"),
                                      qmi_wds_extended_data_bearer_technology_3gpp_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_wds_extended_data_bearer_technology_3gpp_build_string_from_mask (QmiWdsExtendedDataBearerTechnology3gpp mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_wds_extended_data_bearer_technology_3gpp_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_wds_extended_data_bearer_technology_3gpp_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_wds_extended_data_bearer_technology_3gpp_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_wds_extended_data_bearer_technology_3gpp_values[i].value) {
            guint c;
            gulong number = qmi_wds_extended_data_bearer_technology_3gpp_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_wds_extended_data_bearer_technology_3gpp_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}
static const GFlagsValue qmi_wds_extended_data_bearer_technology_3gpp2_values[] = {
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_UNKNOWN, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_UNKNOWN", "unknown" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_RESERVED, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_RESERVED", "reserved" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_CDMA1X_IS95, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_CDMA1X_IS95", "cdma1x-is95" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_CDMA1X_IS2000, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_CDMA1X_IS2000", "cdma1x-is2000" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_CDMA1X_IS2000_REL_A, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_CDMA1X_IS2000_REL_A", "cdma1x-is2000-rel-a" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_HDR_REV_0_DPA, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_HDR_REV_0_DPA", "hdr-rev-0-dpa" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_HDR_REV_A_DPA, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_HDR_REV_A_DPA", "hdr-rev-a-dpa" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_HDR_REV_B_DPA, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_HDR_REV_B_DPA", "hdr-rev-b-dpa" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_HDR_REV_A_MPA, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_HDR_REV_A_MPA", "hdr-rev-a-mpa" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_HDR_REV_B_MPA, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_HDR_REV_B_MPA", "hdr-rev-b-mpa" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_HDR_REV_A_EMPA, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_HDR_REV_A_EMPA", "hdr-rev-a-empa" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_HDR_REV_B_EMPA, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_HDR_REV_B_EMPA", "hdr-rev-b-empa" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_HDR_REV_B_MMPA, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_HDR_REV_B_MMPA", "hdr-rev-b-mmpa" },
    { QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_HDR_EVDO_FMC, "QMI_WDS_EXTENDED_DATA_BEARER_TECHNOLOGY_3GPP2_HDR_EVDO_FMC", "hdr-evdo-fmc" },
    { 0, NULL, NULL }
};

/* Define type-specific symbols */

GType
qmi_wds_extended_data_bearer_technology_3gpp2_get_type (void)
{
    static gsize g_define_type_id_initialized = 0;

    if (g_once_init_enter (&g_define_type_id_initialized)) {
        GType g_define_type_id =
            g_flags_register_static (g_intern_static_string ("QmiWdsExtendedDataBearerTechnology3gpp2"),
                                      qmi_wds_extended_data_bearer_technology_3gpp2_values);
        g_once_init_leave (&g_define_type_id_initialized, g_define_type_id);
    }

    return g_define_type_id_initialized;
}

/* Flags-specific method to build a string with the given mask.
 * We get a comma separated list of the nicks of the GFlagsValues.
 * Note that this will be valid even if the GFlagsClass is not referenced
 * anywhere. */
gchar *
qmi_wds_extended_data_bearer_technology_3gpp2_build_string_from_mask (QmiWdsExtendedDataBearerTechnology3gpp2 mask)
{
    guint i;
    gboolean first = TRUE;
    GString *str = NULL;

    for (i = 0; qmi_wds_extended_data_bearer_technology_3gpp2_values[i].value_nick; i++) {
        /* We also look for exact matches */
      if ((guint)mask == qmi_wds_extended_data_bearer_technology_3gpp2_values[i].value) {
            if (str)
                g_string_free (str, TRUE);
            return g_strdup (qmi_wds_extended_data_bearer_technology_3gpp2_values[i].value_nick);
        }

        /* Build list with single-bit masks */
        if (mask & qmi_wds_extended_data_bearer_technology_3gpp2_values[i].value) {
            guint c;
            gulong number = qmi_wds_extended_data_bearer_technology_3gpp2_values[i].value;

            for (c = 0; number; c++)
                number &= number - 1;

            if (c == 1) {
                if (!str)
                    str = g_string_new ("");
                g_string_append_printf (str, "%s%s",
                                        first ? "" : ", ",
                                        qmi_wds_extended_data_bearer_technology_3gpp2_values[i].value_nick);
                if (first)
                    first = FALSE;
            }
        }
    }

    return (str ? g_string_free (str, FALSE) : NULL);
}

/* Generated data ends here */

