
/* 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 "gs-enums.h"
#include "gnome-software.h"
#include "gs-app.h"
#include "gs-app-collation.h"
#include "gs-app-list.h"
#include "gs-app-permissions.h"
#include "gs-app-query.h"
#include "gs-appstream.h"
#include "gs-category.h"
#include "gs-category-manager.h"
#include "gs-desktop-data.h"
#include "gs-download-utils.h"
#include "gs-external-appstream-utils.h"
#include "gs-icon.h"
#include "gs-ioprio.h"
#include "gs-key-colors.h"
#include "gs-metered.h"
#include "gs-odrs-provider.h"
#include "gs-os-release.h"
#include "gs-plugin.h"
#include "gs-plugin-event.h"
#include "gs-plugin-helpers.h"
#include "gs-plugin-job.h"
#include "gs-plugin-job-list-apps.h"
#include "gs-plugin-job-list-categories.h"
#include "gs-plugin-job-list-distro-upgrades.h"
#include "gs-plugin-job-manage-repository.h"
#include "gs-plugin-job-refine.h"
#include "gs-plugin-job-refresh-metadata.h"
#include "gs-plugin-loader.h"
#include "gs-plugin-loader-sync.h"
#include "gs-plugin-types.h"
#include "gs-plugin-vfuncs.h"
#include "gs-remote-icon.h"
#include "gs-test.h"
#include "gs-utils.h"
#include "gs-worker-thread.h"

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

/* enumerations from "gs-app-list.h" */

GType
gs_app_list_filter_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GS_APP_LIST_FILTER_FLAG_NONE), "GS_APP_LIST_FILTER_FLAG_NONE", "none" },
    { C_FLAGS(GS_APP_LIST_FILTER_FLAG_KEY_ID), "GS_APP_LIST_FILTER_FLAG_KEY_ID", "key-id" },
    { C_FLAGS(GS_APP_LIST_FILTER_FLAG_KEY_SOURCE), "GS_APP_LIST_FILTER_FLAG_KEY_SOURCE", "key-source" },
    { C_FLAGS(GS_APP_LIST_FILTER_FLAG_KEY_VERSION), "GS_APP_LIST_FILTER_FLAG_KEY_VERSION", "key-version" },
    { C_FLAGS(GS_APP_LIST_FILTER_FLAG_PREFER_INSTALLED), "GS_APP_LIST_FILTER_FLAG_PREFER_INSTALLED", "prefer-installed" },
    { C_FLAGS(GS_APP_LIST_FILTER_FLAG_KEY_ID_PROVIDES), "GS_APP_LIST_FILTER_FLAG_KEY_ID_PROVIDES", "key-id-provides" },
    { C_FLAGS(GS_APP_LIST_FILTER_FLAG_MASK), "GS_APP_LIST_FILTER_FLAG_MASK", "mask" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GsAppListFilterFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gs-app-permissions.h" */

GType
gs_app_permissions_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GS_APP_PERMISSIONS_FLAGS_UNKNOWN), "GS_APP_PERMISSIONS_FLAGS_UNKNOWN", "unknown" },
    { C_FLAGS(GS_APP_PERMISSIONS_FLAGS_NONE), "GS_APP_PERMISSIONS_FLAGS_NONE", "none" },
    { C_FLAGS(GS_APP_PERMISSIONS_FLAGS_NETWORK), "GS_APP_PERMISSIONS_FLAGS_NETWORK", "network" },
    { C_FLAGS(GS_APP_PERMISSIONS_FLAGS_SYSTEM_BUS), "GS_APP_PERMISSIONS_FLAGS_SYSTEM_BUS", "system-bus" },
    { C_FLAGS(GS_APP_PERMISSIONS_FLAGS_SESSION_BUS), "GS_APP_PERMISSIONS_FLAGS_SESSION_BUS", "session-bus" },
    { C_FLAGS(GS_APP_PERMISSIONS_FLAGS_DEVICES), "GS_APP_PERMISSIONS_FLAGS_DEVICES", "devices" },
    { C_FLAGS(GS_APP_PERMISSIONS_FLAGS_HOME_FULL), "GS_APP_PERMISSIONS_FLAGS_HOME_FULL", "home-full" },
    { C_FLAGS(GS_APP_PERMISSIONS_FLAGS_HOME_READ), "GS_APP_PERMISSIONS_FLAGS_HOME_READ", "home-read" },
    { C_FLAGS(GS_APP_PERMISSIONS_FLAGS_FILESYSTEM_FULL), "GS_APP_PERMISSIONS_FLAGS_FILESYSTEM_FULL", "filesystem-full" },
    { C_FLAGS(GS_APP_PERMISSIONS_FLAGS_FILESYSTEM_READ), "GS_APP_PERMISSIONS_FLAGS_FILESYSTEM_READ", "filesystem-read" },
    { C_FLAGS(GS_APP_PERMISSIONS_FLAGS_DOWNLOADS_FULL), "GS_APP_PERMISSIONS_FLAGS_DOWNLOADS_FULL", "downloads-full" },
    { C_FLAGS(GS_APP_PERMISSIONS_FLAGS_DOWNLOADS_READ), "GS_APP_PERMISSIONS_FLAGS_DOWNLOADS_READ", "downloads-read" },
    { C_FLAGS(GS_APP_PERMISSIONS_FLAGS_SETTINGS), "GS_APP_PERMISSIONS_FLAGS_SETTINGS", "settings" },
    { C_FLAGS(GS_APP_PERMISSIONS_FLAGS_X11), "GS_APP_PERMISSIONS_FLAGS_X11", "x11" },
    { C_FLAGS(GS_APP_PERMISSIONS_FLAGS_ESCAPE_SANDBOX), "GS_APP_PERMISSIONS_FLAGS_ESCAPE_SANDBOX", "escape-sandbox" },
    { C_FLAGS(GS_APP_PERMISSIONS_FLAGS_FILESYSTEM_OTHER), "GS_APP_PERMISSIONS_FLAGS_FILESYSTEM_OTHER", "filesystem-other" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GsAppPermissionsFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gs-app-query.h" */

GType
gs_app_query_tristate_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GS_APP_QUERY_TRISTATE_UNSET), "GS_APP_QUERY_TRISTATE_UNSET", "unset" },
    { C_ENUM(GS_APP_QUERY_TRISTATE_FALSE), "GS_APP_QUERY_TRISTATE_FALSE", "false" },
    { C_ENUM(GS_APP_QUERY_TRISTATE_TRUE), "GS_APP_QUERY_TRISTATE_TRUE", "true" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GsAppQueryTristate"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gs_app_query_provides_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GS_APP_QUERY_PROVIDES_UNKNOWN), "GS_APP_QUERY_PROVIDES_UNKNOWN", "unknown" },
    { C_ENUM(GS_APP_QUERY_PROVIDES_PACKAGE_NAME), "GS_APP_QUERY_PROVIDES_PACKAGE_NAME", "package-name" },
    { C_ENUM(GS_APP_QUERY_PROVIDES_GSTREAMER), "GS_APP_QUERY_PROVIDES_GSTREAMER", "gstreamer" },
    { C_ENUM(GS_APP_QUERY_PROVIDES_FONT), "GS_APP_QUERY_PROVIDES_FONT", "font" },
    { C_ENUM(GS_APP_QUERY_PROVIDES_MIME_HANDLER), "GS_APP_QUERY_PROVIDES_MIME_HANDLER", "mime-handler" },
    { C_ENUM(GS_APP_QUERY_PROVIDES_PS_DRIVER), "GS_APP_QUERY_PROVIDES_PS_DRIVER", "ps-driver" },
    { C_ENUM(GS_APP_QUERY_PROVIDES_PLASMA), "GS_APP_QUERY_PROVIDES_PLASMA", "plasma" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GsAppQueryProvidesType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gs-app.h" */

GType
gs_app_state_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GS_APP_STATE_UNKNOWN), "GS_APP_STATE_UNKNOWN", "unknown" },
    { C_ENUM(GS_APP_STATE_INSTALLED), "GS_APP_STATE_INSTALLED", "installed" },
    { C_ENUM(GS_APP_STATE_AVAILABLE), "GS_APP_STATE_AVAILABLE", "available" },
    { C_ENUM(GS_APP_STATE_AVAILABLE_LOCAL), "GS_APP_STATE_AVAILABLE_LOCAL", "available-local" },
    { C_ENUM(GS_APP_STATE_UPDATABLE), "GS_APP_STATE_UPDATABLE", "updatable" },
    { C_ENUM(GS_APP_STATE_UNAVAILABLE), "GS_APP_STATE_UNAVAILABLE", "unavailable" },
    { C_ENUM(GS_APP_STATE_QUEUED_FOR_INSTALL), "GS_APP_STATE_QUEUED_FOR_INSTALL", "queued-for-install" },
    { C_ENUM(GS_APP_STATE_INSTALLING), "GS_APP_STATE_INSTALLING", "installing" },
    { C_ENUM(GS_APP_STATE_REMOVING), "GS_APP_STATE_REMOVING", "removing" },
    { C_ENUM(GS_APP_STATE_UPDATABLE_LIVE), "GS_APP_STATE_UPDATABLE_LIVE", "updatable-live" },
    { C_ENUM(GS_APP_STATE_PURCHASABLE), "GS_APP_STATE_PURCHASABLE", "purchasable" },
    { C_ENUM(GS_APP_STATE_PURCHASING), "GS_APP_STATE_PURCHASING", "purchasing" },
    { C_ENUM(GS_APP_STATE_PENDING_INSTALL), "GS_APP_STATE_PENDING_INSTALL", "pending-install" },
    { C_ENUM(GS_APP_STATE_PENDING_REMOVE), "GS_APP_STATE_PENDING_REMOVE", "pending-remove" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GsAppState"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gs_app_special_kind_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GS_APP_SPECIAL_KIND_NONE), "GS_APP_SPECIAL_KIND_NONE", "none" },
    { C_ENUM(GS_APP_SPECIAL_KIND_OS_UPDATE), "GS_APP_SPECIAL_KIND_OS_UPDATE", "os-update" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GsAppSpecialKind"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gs_app_kudo_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GS_APP_KUDO_MY_LANGUAGE), "GS_APP_KUDO_MY_LANGUAGE", "my-language" },
    { C_FLAGS(GS_APP_KUDO_RECENT_RELEASE), "GS_APP_KUDO_RECENT_RELEASE", "recent-release" },
    { C_FLAGS(GS_APP_KUDO_FEATURED_RECOMMENDED), "GS_APP_KUDO_FEATURED_RECOMMENDED", "featured-recommended" },
    { C_FLAGS(GS_APP_KUDO_MODERN_TOOLKIT), "GS_APP_KUDO_MODERN_TOOLKIT", "modern-toolkit" },
    { C_FLAGS(GS_APP_KUDO_SEARCH_PROVIDER), "GS_APP_KUDO_SEARCH_PROVIDER", "search-provider" },
    { C_FLAGS(GS_APP_KUDO_INSTALLS_USER_DOCS), "GS_APP_KUDO_INSTALLS_USER_DOCS", "installs-user-docs" },
    { C_FLAGS(GS_APP_KUDO_USES_NOTIFICATIONS), "GS_APP_KUDO_USES_NOTIFICATIONS", "uses-notifications" },
    { C_FLAGS(GS_APP_KUDO_HAS_KEYWORDS), "GS_APP_KUDO_HAS_KEYWORDS", "has-keywords" },
    { C_FLAGS(GS_APP_KUDO_HAS_SCREENSHOTS), "GS_APP_KUDO_HAS_SCREENSHOTS", "has-screenshots" },
    { C_FLAGS(GS_APP_KUDO_HIGH_CONTRAST), "GS_APP_KUDO_HIGH_CONTRAST", "high-contrast" },
    { C_FLAGS(GS_APP_KUDO_HI_DPI_ICON), "GS_APP_KUDO_HI_DPI_ICON", "hi-dpi-icon" },
    { C_FLAGS(GS_APP_KUDO_SANDBOXED), "GS_APP_KUDO_SANDBOXED", "sandboxed" },
    { C_FLAGS(GS_APP_KUDO_SANDBOXED_SECURE), "GS_APP_KUDO_SANDBOXED_SECURE", "sandboxed-secure" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GsAppKudo"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gs_app_quirk_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GS_APP_QUIRK_NONE), "GS_APP_QUIRK_NONE", "none" },
    { C_FLAGS(GS_APP_QUIRK_PROVENANCE), "GS_APP_QUIRK_PROVENANCE", "provenance" },
    { C_FLAGS(GS_APP_QUIRK_COMPULSORY), "GS_APP_QUIRK_COMPULSORY", "compulsory" },
    { C_FLAGS(GS_APP_QUIRK_HAS_SOURCE), "GS_APP_QUIRK_HAS_SOURCE", "has-source" },
    { C_FLAGS(GS_APP_QUIRK_IS_WILDCARD), "GS_APP_QUIRK_IS_WILDCARD", "is-wildcard" },
    { C_FLAGS(GS_APP_QUIRK_NEEDS_REBOOT), "GS_APP_QUIRK_NEEDS_REBOOT", "needs-reboot" },
    { C_FLAGS(GS_APP_QUIRK_NOT_REVIEWABLE), "GS_APP_QUIRK_NOT_REVIEWABLE", "not-reviewable" },
    { C_FLAGS(GS_APP_QUIRK_NOT_LAUNCHABLE), "GS_APP_QUIRK_NOT_LAUNCHABLE", "not-launchable" },
    { C_FLAGS(GS_APP_QUIRK_NEEDS_USER_ACTION), "GS_APP_QUIRK_NEEDS_USER_ACTION", "needs-user-action" },
    { C_FLAGS(GS_APP_QUIRK_IS_PROXY), "GS_APP_QUIRK_IS_PROXY", "is-proxy" },
    { C_FLAGS(GS_APP_QUIRK_REMOVABLE_HARDWARE), "GS_APP_QUIRK_REMOVABLE_HARDWARE", "removable-hardware" },
    { C_FLAGS(GS_APP_QUIRK_DEVELOPER_VERIFIED), "GS_APP_QUIRK_DEVELOPER_VERIFIED", "developer-verified" },
    { C_FLAGS(GS_APP_QUIRK_PARENTAL_FILTER), "GS_APP_QUIRK_PARENTAL_FILTER", "parental-filter" },
    { C_FLAGS(GS_APP_QUIRK_NEW_PERMISSIONS), "GS_APP_QUIRK_NEW_PERMISSIONS", "new-permissions" },
    { C_FLAGS(GS_APP_QUIRK_PARENTAL_NOT_LAUNCHABLE), "GS_APP_QUIRK_PARENTAL_NOT_LAUNCHABLE", "parental-not-launchable" },
    { C_FLAGS(GS_APP_QUIRK_HIDE_FROM_SEARCH), "GS_APP_QUIRK_HIDE_FROM_SEARCH", "hide-from-search" },
    { C_FLAGS(GS_APP_QUIRK_HIDE_EVERYWHERE), "GS_APP_QUIRK_HIDE_EVERYWHERE", "hide-everywhere" },
    { C_FLAGS(GS_APP_QUIRK_DO_NOT_AUTO_UPDATE), "GS_APP_QUIRK_DO_NOT_AUTO_UPDATE", "do-not-auto-update" },
    { C_FLAGS(GS_APP_QUIRK_DEVELOPMENT_SOURCE), "GS_APP_QUIRK_DEVELOPMENT_SOURCE", "development-source" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GsAppQuirk"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gs_size_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GS_SIZE_TYPE_UNKNOWN), "GS_SIZE_TYPE_UNKNOWN", "unknown" },
    { C_ENUM(GS_SIZE_TYPE_UNKNOWABLE), "GS_SIZE_TYPE_UNKNOWABLE", "unknowable" },
    { C_ENUM(GS_SIZE_TYPE_VALID), "GS_SIZE_TYPE_VALID", "valid" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GsSizeType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gs_app_quality_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GS_APP_QUALITY_UNKNOWN), "GS_APP_QUALITY_UNKNOWN", "unknown" },
    { C_ENUM(GS_APP_QUALITY_LOWEST), "GS_APP_QUALITY_LOWEST", "lowest" },
    { C_ENUM(GS_APP_QUALITY_NORMAL), "GS_APP_QUALITY_NORMAL", "normal" },
    { C_ENUM(GS_APP_QUALITY_HIGHEST), "GS_APP_QUALITY_HIGHEST", "highest" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GsAppQuality"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gs-download-utils.h" */

GType
gs_download_error_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GS_DOWNLOAD_ERROR_NOT_MODIFIED), "GS_DOWNLOAD_ERROR_NOT_MODIFIED", "modified" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GsDownloadError"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gs-external-appstream-utils.h" */

GType
gs_external_appstream_error_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GS_EXTERNAL_APPSTREAM_ERROR_DOWNLOADING), "GS_EXTERNAL_APPSTREAM_ERROR_DOWNLOADING", "downloading" },
    { C_ENUM(GS_EXTERNAL_APPSTREAM_ERROR_NO_NETWORK), "GS_EXTERNAL_APPSTREAM_ERROR_NO_NETWORK", "no-network" },
    { C_ENUM(GS_EXTERNAL_APPSTREAM_ERROR_INSTALLING_ON_SYSTEM), "GS_EXTERNAL_APPSTREAM_ERROR_INSTALLING_ON_SYSTEM", "installing-on-system" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GsExternalAppstreamError"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gs-odrs-provider.h" */

GType
gs_odrs_provider_error_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GS_ODRS_PROVIDER_ERROR_DOWNLOADING), "GS_ODRS_PROVIDER_ERROR_DOWNLOADING", "downloading" },
    { C_ENUM(GS_ODRS_PROVIDER_ERROR_PARSING_DATA), "GS_ODRS_PROVIDER_ERROR_PARSING_DATA", "parsing-data" },
    { C_ENUM(GS_ODRS_PROVIDER_ERROR_NO_NETWORK), "GS_ODRS_PROVIDER_ERROR_NO_NETWORK", "no-network" },
    { C_ENUM(GS_ODRS_PROVIDER_ERROR_SERVER_ERROR), "GS_ODRS_PROVIDER_ERROR_SERVER_ERROR", "server-error" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GsOdrsProviderError"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gs_odrs_provider_refine_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GS_ODRS_PROVIDER_REFINE_FLAGS_GET_RATINGS), "GS_ODRS_PROVIDER_REFINE_FLAGS_GET_RATINGS", "ratings" },
    { C_FLAGS(GS_ODRS_PROVIDER_REFINE_FLAGS_GET_REVIEWS), "GS_ODRS_PROVIDER_REFINE_FLAGS_GET_REVIEWS", "reviews" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GsOdrsProviderRefineFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gs-plugin-event.h" */

GType
gs_plugin_event_flag_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GS_PLUGIN_EVENT_FLAG_NONE), "GS_PLUGIN_EVENT_FLAG_NONE", "none" },
    { C_FLAGS(GS_PLUGIN_EVENT_FLAG_INVALID), "GS_PLUGIN_EVENT_FLAG_INVALID", "invalid" },
    { C_FLAGS(GS_PLUGIN_EVENT_FLAG_VISIBLE), "GS_PLUGIN_EVENT_FLAG_VISIBLE", "visible" },
    { C_FLAGS(GS_PLUGIN_EVENT_FLAG_WARNING), "GS_PLUGIN_EVENT_FLAG_WARNING", "warning" },
    { C_FLAGS(GS_PLUGIN_EVENT_FLAG_INTERACTIVE), "GS_PLUGIN_EVENT_FLAG_INTERACTIVE", "interactive" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GsPluginEventFlag"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gs-plugin-types.h" */

GType
gs_plugin_status_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GS_PLUGIN_STATUS_UNKNOWN), "GS_PLUGIN_STATUS_UNKNOWN", "unknown" },
    { C_ENUM(GS_PLUGIN_STATUS_WAITING), "GS_PLUGIN_STATUS_WAITING", "waiting" },
    { C_ENUM(GS_PLUGIN_STATUS_FINISHED), "GS_PLUGIN_STATUS_FINISHED", "finished" },
    { C_ENUM(GS_PLUGIN_STATUS_SETUP), "GS_PLUGIN_STATUS_SETUP", "setup" },
    { C_ENUM(GS_PLUGIN_STATUS_DOWNLOADING), "GS_PLUGIN_STATUS_DOWNLOADING", "downloading" },
    { C_ENUM(GS_PLUGIN_STATUS_QUERYING), "GS_PLUGIN_STATUS_QUERYING", "querying" },
    { C_ENUM(GS_PLUGIN_STATUS_INSTALLING), "GS_PLUGIN_STATUS_INSTALLING", "installing" },
    { C_ENUM(GS_PLUGIN_STATUS_REMOVING), "GS_PLUGIN_STATUS_REMOVING", "removing" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GsPluginStatus"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gs_plugin_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GS_PLUGIN_FLAGS_NONE), "GS_PLUGIN_FLAGS_NONE", "none" },
    { C_FLAGS(GS_PLUGIN_FLAGS_INTERACTIVE), "GS_PLUGIN_FLAGS_INTERACTIVE", "interactive" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GsPluginFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gs_plugin_error_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GS_PLUGIN_ERROR_FAILED), "GS_PLUGIN_ERROR_FAILED", "failed" },
    { C_ENUM(GS_PLUGIN_ERROR_NOT_SUPPORTED), "GS_PLUGIN_ERROR_NOT_SUPPORTED", "not-supported" },
    { C_ENUM(GS_PLUGIN_ERROR_CANCELLED), "GS_PLUGIN_ERROR_CANCELLED", "cancelled" },
    { C_ENUM(GS_PLUGIN_ERROR_NO_NETWORK), "GS_PLUGIN_ERROR_NO_NETWORK", "no-network" },
    { C_ENUM(GS_PLUGIN_ERROR_NO_SECURITY), "GS_PLUGIN_ERROR_NO_SECURITY", "no-security" },
    { C_ENUM(GS_PLUGIN_ERROR_NO_SPACE), "GS_PLUGIN_ERROR_NO_SPACE", "no-space" },
    { C_ENUM(GS_PLUGIN_ERROR_AUTH_REQUIRED), "GS_PLUGIN_ERROR_AUTH_REQUIRED", "auth-required" },
    { C_ENUM(GS_PLUGIN_ERROR_AUTH_INVALID), "GS_PLUGIN_ERROR_AUTH_INVALID", "auth-invalid" },
    { C_ENUM(GS_PLUGIN_ERROR_PLUGIN_DEPSOLVE_FAILED), "GS_PLUGIN_ERROR_PLUGIN_DEPSOLVE_FAILED", "plugin-depsolve-failed" },
    { C_ENUM(GS_PLUGIN_ERROR_DOWNLOAD_FAILED), "GS_PLUGIN_ERROR_DOWNLOAD_FAILED", "download-failed" },
    { C_ENUM(GS_PLUGIN_ERROR_WRITE_FAILED), "GS_PLUGIN_ERROR_WRITE_FAILED", "write-failed" },
    { C_ENUM(GS_PLUGIN_ERROR_INVALID_FORMAT), "GS_PLUGIN_ERROR_INVALID_FORMAT", "invalid-format" },
    { C_ENUM(GS_PLUGIN_ERROR_DELETE_FAILED), "GS_PLUGIN_ERROR_DELETE_FAILED", "delete-failed" },
    { C_ENUM(GS_PLUGIN_ERROR_RESTART_REQUIRED), "GS_PLUGIN_ERROR_RESTART_REQUIRED", "restart-required" },
    { C_ENUM(GS_PLUGIN_ERROR_AC_POWER_REQUIRED), "GS_PLUGIN_ERROR_AC_POWER_REQUIRED", "ac-power-required" },
    { C_ENUM(GS_PLUGIN_ERROR_TIMED_OUT), "GS_PLUGIN_ERROR_TIMED_OUT", "timed-out" },
    { C_ENUM(GS_PLUGIN_ERROR_BATTERY_LEVEL_TOO_LOW), "GS_PLUGIN_ERROR_BATTERY_LEVEL_TOO_LOW", "battery-level-too-low" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GsPluginError"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gs_plugin_refine_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_NONE), "GS_PLUGIN_REFINE_FLAGS_NONE", "none" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_ID), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_ID", "require-id" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_LICENSE), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_LICENSE", "require-license" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_URL), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_URL", "require-url" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_DESCRIPTION), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_DESCRIPTION", "require-description" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_SIZE), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_SIZE", "require-size" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_RATING), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_RATING", "require-rating" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_VERSION), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_VERSION", "require-version" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_HISTORY), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_HISTORY", "require-history" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_SETUP_ACTION), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_SETUP_ACTION", "require-setup-action" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_UPDATE_DETAILS), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_UPDATE_DETAILS", "require-update-details" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN", "require-origin" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_RELATED), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_RELATED", "require-related" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_SIZE_DATA), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_SIZE_DATA", "require-size-data" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_ADDONS), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_ADDONS", "require-addons" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_ALLOW_PACKAGES), "GS_PLUGIN_REFINE_FLAGS_ALLOW_PACKAGES", "allow-packages" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_UPDATE_SEVERITY), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_UPDATE_SEVERITY", "require-update-severity" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_UPGRADE_REMOVED), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_UPGRADE_REMOVED", "require-upgrade-removed" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_PROVENANCE), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_PROVENANCE", "require-provenance" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_REVIEWS), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_REVIEWS", "require-reviews" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_REVIEW_RATINGS), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_REVIEW_RATINGS", "require-review-ratings" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_DISABLE_FILTERING), "GS_PLUGIN_REFINE_FLAGS_DISABLE_FILTERING", "disable-filtering" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_ICON), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_ICON", "require-icon" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_PERMISSIONS), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_PERMISSIONS", "require-permissions" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN_HOSTNAME), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN_HOSTNAME", "require-origin-hostname" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN_UI), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN_UI", "require-origin-ui" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_RUNTIME), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_RUNTIME", "require-runtime" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_SCREENSHOTS), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_SCREENSHOTS", "require-screenshots" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_CATEGORIES), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_CATEGORIES", "require-categories" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_PROJECT_GROUP), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_PROJECT_GROUP", "require-project-group" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_DEVELOPER_NAME), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_DEVELOPER_NAME", "require-developer-name" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_KUDOS), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_KUDOS", "require-kudos" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_REQUIRE_CONTENT_RATING), "GS_PLUGIN_REFINE_FLAGS_REQUIRE_CONTENT_RATING", "require-content-rating" },
    { C_FLAGS(GS_PLUGIN_REFINE_FLAGS_MASK), "GS_PLUGIN_REFINE_FLAGS_MASK", "mask" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GsPluginRefineFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gs_plugin_list_apps_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GS_PLUGIN_LIST_APPS_FLAGS_NONE), "GS_PLUGIN_LIST_APPS_FLAGS_NONE", "none" },
    { C_FLAGS(GS_PLUGIN_LIST_APPS_FLAGS_INTERACTIVE), "GS_PLUGIN_LIST_APPS_FLAGS_INTERACTIVE", "interactive" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GsPluginListAppsFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gs_plugin_refine_categories_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GS_PLUGIN_REFINE_CATEGORIES_FLAGS_NONE), "GS_PLUGIN_REFINE_CATEGORIES_FLAGS_NONE", "none" },
    { C_FLAGS(GS_PLUGIN_REFINE_CATEGORIES_FLAGS_INTERACTIVE), "GS_PLUGIN_REFINE_CATEGORIES_FLAGS_INTERACTIVE", "interactive" },
    { C_FLAGS(GS_PLUGIN_REFINE_CATEGORIES_FLAGS_SIZE), "GS_PLUGIN_REFINE_CATEGORIES_FLAGS_SIZE", "size" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GsPluginRefineCategoriesFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gs_plugin_refresh_metadata_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GS_PLUGIN_REFRESH_METADATA_FLAGS_NONE), "GS_PLUGIN_REFRESH_METADATA_FLAGS_NONE", "none" },
    { C_FLAGS(GS_PLUGIN_REFRESH_METADATA_FLAGS_INTERACTIVE), "GS_PLUGIN_REFRESH_METADATA_FLAGS_INTERACTIVE", "interactive" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GsPluginRefreshMetadataFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gs_plugin_list_distro_upgrades_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GS_PLUGIN_LIST_DISTRO_UPGRADES_FLAGS_NONE), "GS_PLUGIN_LIST_DISTRO_UPGRADES_FLAGS_NONE", "none" },
    { C_FLAGS(GS_PLUGIN_LIST_DISTRO_UPGRADES_FLAGS_INTERACTIVE), "GS_PLUGIN_LIST_DISTRO_UPGRADES_FLAGS_INTERACTIVE", "interactive" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GsPluginListDistroUpgradesFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gs_plugin_manage_repository_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GS_PLUGIN_MANAGE_REPOSITORY_FLAGS_NONE), "GS_PLUGIN_MANAGE_REPOSITORY_FLAGS_NONE", "none" },
    { C_FLAGS(GS_PLUGIN_MANAGE_REPOSITORY_FLAGS_INTERACTIVE), "GS_PLUGIN_MANAGE_REPOSITORY_FLAGS_INTERACTIVE", "interactive" },
    { C_FLAGS(GS_PLUGIN_MANAGE_REPOSITORY_FLAGS_INSTALL), "GS_PLUGIN_MANAGE_REPOSITORY_FLAGS_INSTALL", "install" },
    { C_FLAGS(GS_PLUGIN_MANAGE_REPOSITORY_FLAGS_REMOVE), "GS_PLUGIN_MANAGE_REPOSITORY_FLAGS_REMOVE", "remove" },
    { C_FLAGS(GS_PLUGIN_MANAGE_REPOSITORY_FLAGS_ENABLE), "GS_PLUGIN_MANAGE_REPOSITORY_FLAGS_ENABLE", "enable" },
    { C_FLAGS(GS_PLUGIN_MANAGE_REPOSITORY_FLAGS_DISABLE), "GS_PLUGIN_MANAGE_REPOSITORY_FLAGS_DISABLE", "disable" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GsPluginManageRepositoryFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gs_plugin_rule_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GS_PLUGIN_RULE_CONFLICTS), "GS_PLUGIN_RULE_CONFLICTS", "conflicts" },
    { C_ENUM(GS_PLUGIN_RULE_RUN_AFTER), "GS_PLUGIN_RULE_RUN_AFTER", "run-after" },
    { C_ENUM(GS_PLUGIN_RULE_RUN_BEFORE), "GS_PLUGIN_RULE_RUN_BEFORE", "run-before" },
    { C_ENUM(GS_PLUGIN_RULE_BETTER_THAN), "GS_PLUGIN_RULE_BETTER_THAN", "better-than" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GsPluginRule"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gs_plugin_action_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GS_PLUGIN_ACTION_UNKNOWN), "GS_PLUGIN_ACTION_UNKNOWN", "unknown" },
    { C_ENUM(GS_PLUGIN_ACTION_INSTALL), "GS_PLUGIN_ACTION_INSTALL", "install" },
    { C_ENUM(GS_PLUGIN_ACTION_REMOVE), "GS_PLUGIN_ACTION_REMOVE", "remove" },
    { C_ENUM(GS_PLUGIN_ACTION_UPDATE), "GS_PLUGIN_ACTION_UPDATE", "update" },
    { C_ENUM(GS_PLUGIN_ACTION_UPGRADE_DOWNLOAD), "GS_PLUGIN_ACTION_UPGRADE_DOWNLOAD", "upgrade-download" },
    { C_ENUM(GS_PLUGIN_ACTION_UPGRADE_TRIGGER), "GS_PLUGIN_ACTION_UPGRADE_TRIGGER", "upgrade-trigger" },
    { C_ENUM(GS_PLUGIN_ACTION_LAUNCH), "GS_PLUGIN_ACTION_LAUNCH", "launch" },
    { C_ENUM(GS_PLUGIN_ACTION_UPDATE_CANCEL), "GS_PLUGIN_ACTION_UPDATE_CANCEL", "update-cancel" },
    { C_ENUM(GS_PLUGIN_ACTION_GET_UPDATES), "GS_PLUGIN_ACTION_GET_UPDATES", "get-updates" },
    { C_ENUM(GS_PLUGIN_ACTION_GET_SOURCES), "GS_PLUGIN_ACTION_GET_SOURCES", "get-sources" },
    { C_ENUM(GS_PLUGIN_ACTION_FILE_TO_APP), "GS_PLUGIN_ACTION_FILE_TO_APP", "file-to-app" },
    { C_ENUM(GS_PLUGIN_ACTION_URL_TO_APP), "GS_PLUGIN_ACTION_URL_TO_APP", "url-to-app" },
    { C_ENUM(GS_PLUGIN_ACTION_GET_UPDATES_HISTORICAL), "GS_PLUGIN_ACTION_GET_UPDATES_HISTORICAL", "get-updates-historical" },
    { C_ENUM(GS_PLUGIN_ACTION_DOWNLOAD), "GS_PLUGIN_ACTION_DOWNLOAD", "download" },
    { C_ENUM(GS_PLUGIN_ACTION_GET_LANGPACKS), "GS_PLUGIN_ACTION_GET_LANGPACKS", "get-langpacks" },
    { C_ENUM(GS_PLUGIN_ACTION_INSTALL_REPO), "GS_PLUGIN_ACTION_INSTALL_REPO", "install-repo" },
    { C_ENUM(GS_PLUGIN_ACTION_REMOVE_REPO), "GS_PLUGIN_ACTION_REMOVE_REPO", "remove-repo" },
    { C_ENUM(GS_PLUGIN_ACTION_ENABLE_REPO), "GS_PLUGIN_ACTION_ENABLE_REPO", "enable-repo" },
    { C_ENUM(GS_PLUGIN_ACTION_DISABLE_REPO), "GS_PLUGIN_ACTION_DISABLE_REPO", "disable-repo" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GsPluginAction"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

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

GType
gs_utils_cache_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GS_UTILS_CACHE_FLAG_NONE), "GS_UTILS_CACHE_FLAG_NONE", "none" },
    { C_FLAGS(GS_UTILS_CACHE_FLAG_WRITEABLE), "GS_UTILS_CACHE_FLAG_WRITEABLE", "writeable" },
    { C_FLAGS(GS_UTILS_CACHE_FLAG_USE_HASH), "GS_UTILS_CACHE_FLAG_USE_HASH", "use-hash" },
    { C_FLAGS(GS_UTILS_CACHE_FLAG_ENSURE_EMPTY), "GS_UTILS_CACHE_FLAG_ENSURE_EMPTY", "ensure-empty" },
    { C_FLAGS(GS_UTILS_CACHE_FLAG_CREATE_DIRECTORY), "GS_UTILS_CACHE_FLAG_CREATE_DIRECTORY", "create-directory" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GsUtilsCacheFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* Generated data ends here */

