


#include "config.h"
#include <wocky-enumtypes.h>

/* enumerations from "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-auth-registry.h" */
#include "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-auth-registry.h"
GType
wocky_auth_error_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_AUTH_ERROR_INIT_FAILED, "WOCKY_AUTH_ERROR_INIT_FAILED", "init-failed" },
      { WOCKY_AUTH_ERROR_NOT_SUPPORTED, "WOCKY_AUTH_ERROR_NOT_SUPPORTED", "not-supported" },
      { WOCKY_AUTH_ERROR_NO_SUPPORTED_MECHANISMS, "WOCKY_AUTH_ERROR_NO_SUPPORTED_MECHANISMS", "no-supported-mechanisms" },
      { WOCKY_AUTH_ERROR_NETWORK, "WOCKY_AUTH_ERROR_NETWORK", "network" },
      { WOCKY_AUTH_ERROR_INVALID_REPLY, "WOCKY_AUTH_ERROR_INVALID_REPLY", "invalid-reply" },
      { WOCKY_AUTH_ERROR_NO_CREDENTIALS, "WOCKY_AUTH_ERROR_NO_CREDENTIALS", "no-credentials" },
      { WOCKY_AUTH_ERROR_FAILURE, "WOCKY_AUTH_ERROR_FAILURE", "failure" },
      { WOCKY_AUTH_ERROR_CONNRESET, "WOCKY_AUTH_ERROR_CONNRESET", "connreset" },
      { WOCKY_AUTH_ERROR_STREAM, "WOCKY_AUTH_ERROR_STREAM", "stream" },
      { WOCKY_AUTH_ERROR_RESOURCE_CONFLICT, "WOCKY_AUTH_ERROR_RESOURCE_CONFLICT", "resource-conflict" },
      { WOCKY_AUTH_ERROR_NOT_AUTHORIZED, "WOCKY_AUTH_ERROR_NOT_AUTHORIZED", "not-authorized" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyAuthError", values);
  }
  return etype;
}

/* enumerations from "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-connector.h" */
#include "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-connector.h"
GType
wocky_connector_error_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_CONNECTOR_ERROR_UNKNOWN, "WOCKY_CONNECTOR_ERROR_UNKNOWN", "unknown" },
      { WOCKY_CONNECTOR_ERROR_IN_PROGRESS, "WOCKY_CONNECTOR_ERROR_IN_PROGRESS", "in-progress" },
      { WOCKY_CONNECTOR_ERROR_BAD_JID, "WOCKY_CONNECTOR_ERROR_BAD_JID", "bad-jid" },
      { WOCKY_CONNECTOR_ERROR_NON_XMPP_V1_SERVER, "WOCKY_CONNECTOR_ERROR_NON_XMPP_V1_SERVER", "non-xmpp-v1-server" },
      { WOCKY_CONNECTOR_ERROR_BAD_FEATURES, "WOCKY_CONNECTOR_ERROR_BAD_FEATURES", "bad-features" },
      { WOCKY_CONNECTOR_ERROR_TLS_UNAVAILABLE, "WOCKY_CONNECTOR_ERROR_TLS_UNAVAILABLE", "tls-unavailable" },
      { WOCKY_CONNECTOR_ERROR_TLS_REFUSED, "WOCKY_CONNECTOR_ERROR_TLS_REFUSED", "tls-refused" },
      { WOCKY_CONNECTOR_ERROR_TLS_SESSION_FAILED, "WOCKY_CONNECTOR_ERROR_TLS_SESSION_FAILED", "tls-session-failed" },
      { WOCKY_CONNECTOR_ERROR_BIND_UNAVAILABLE, "WOCKY_CONNECTOR_ERROR_BIND_UNAVAILABLE", "bind-unavailable" },
      { WOCKY_CONNECTOR_ERROR_BIND_FAILED, "WOCKY_CONNECTOR_ERROR_BIND_FAILED", "bind-failed" },
      { WOCKY_CONNECTOR_ERROR_BIND_INVALID, "WOCKY_CONNECTOR_ERROR_BIND_INVALID", "bind-invalid" },
      { WOCKY_CONNECTOR_ERROR_BIND_DENIED, "WOCKY_CONNECTOR_ERROR_BIND_DENIED", "bind-denied" },
      { WOCKY_CONNECTOR_ERROR_BIND_CONFLICT, "WOCKY_CONNECTOR_ERROR_BIND_CONFLICT", "bind-conflict" },
      { WOCKY_CONNECTOR_ERROR_BIND_REJECTED, "WOCKY_CONNECTOR_ERROR_BIND_REJECTED", "bind-rejected" },
      { WOCKY_CONNECTOR_ERROR_SESSION_FAILED, "WOCKY_CONNECTOR_ERROR_SESSION_FAILED", "session-failed" },
      { WOCKY_CONNECTOR_ERROR_SESSION_DENIED, "WOCKY_CONNECTOR_ERROR_SESSION_DENIED", "session-denied" },
      { WOCKY_CONNECTOR_ERROR_SESSION_CONFLICT, "WOCKY_CONNECTOR_ERROR_SESSION_CONFLICT", "session-conflict" },
      { WOCKY_CONNECTOR_ERROR_SESSION_REJECTED, "WOCKY_CONNECTOR_ERROR_SESSION_REJECTED", "session-rejected" },
      { WOCKY_CONNECTOR_ERROR_INSECURE, "WOCKY_CONNECTOR_ERROR_INSECURE", "insecure" },
      { WOCKY_CONNECTOR_ERROR_REGISTRATION_FAILED, "WOCKY_CONNECTOR_ERROR_REGISTRATION_FAILED", "registration-failed" },
      { WOCKY_CONNECTOR_ERROR_REGISTRATION_UNAVAILABLE, "WOCKY_CONNECTOR_ERROR_REGISTRATION_UNAVAILABLE", "registration-unavailable" },
      { WOCKY_CONNECTOR_ERROR_REGISTRATION_UNSUPPORTED, "WOCKY_CONNECTOR_ERROR_REGISTRATION_UNSUPPORTED", "registration-unsupported" },
      { WOCKY_CONNECTOR_ERROR_REGISTRATION_EMPTY, "WOCKY_CONNECTOR_ERROR_REGISTRATION_EMPTY", "registration-empty" },
      { WOCKY_CONNECTOR_ERROR_REGISTRATION_CONFLICT, "WOCKY_CONNECTOR_ERROR_REGISTRATION_CONFLICT", "registration-conflict" },
      { WOCKY_CONNECTOR_ERROR_REGISTRATION_REJECTED, "WOCKY_CONNECTOR_ERROR_REGISTRATION_REJECTED", "registration-rejected" },
      { WOCKY_CONNECTOR_ERROR_UNREGISTER_FAILED, "WOCKY_CONNECTOR_ERROR_UNREGISTER_FAILED", "unregister-failed" },
      { WOCKY_CONNECTOR_ERROR_UNREGISTER_DENIED, "WOCKY_CONNECTOR_ERROR_UNREGISTER_DENIED", "unregister-denied" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyConnectorError", values);
  }
  return etype;
}

/* enumerations from "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-data-form.h" */
#include "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-data-form.h"
GType
wocky_data_form_field_type_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_DATA_FORM_FIELD_TYPE_BOOLEAN, "WOCKY_DATA_FORM_FIELD_TYPE_BOOLEAN", "boolean" },
      { WOCKY_DATA_FORM_FIELD_TYPE_FIXED, "WOCKY_DATA_FORM_FIELD_TYPE_FIXED", "fixed" },
      { WOCKY_DATA_FORM_FIELD_TYPE_HIDDEN, "WOCKY_DATA_FORM_FIELD_TYPE_HIDDEN", "hidden" },
      { WOCKY_DATA_FORM_FIELD_TYPE_JID_MULTI, "WOCKY_DATA_FORM_FIELD_TYPE_JID_MULTI", "jid-multi" },
      { WOCKY_DATA_FORM_FIELD_TYPE_JID_SINGLE, "WOCKY_DATA_FORM_FIELD_TYPE_JID_SINGLE", "jid-single" },
      { WOCKY_DATA_FORM_FIELD_TYPE_LIST_MULTI, "WOCKY_DATA_FORM_FIELD_TYPE_LIST_MULTI", "list-multi" },
      { WOCKY_DATA_FORM_FIELD_TYPE_LIST_SINGLE, "WOCKY_DATA_FORM_FIELD_TYPE_LIST_SINGLE", "list-single" },
      { WOCKY_DATA_FORM_FIELD_TYPE_TEXT_MULTI, "WOCKY_DATA_FORM_FIELD_TYPE_TEXT_MULTI", "text-multi" },
      { WOCKY_DATA_FORM_FIELD_TYPE_TEXT_PRIVATE, "WOCKY_DATA_FORM_FIELD_TYPE_TEXT_PRIVATE", "text-private" },
      { WOCKY_DATA_FORM_FIELD_TYPE_TEXT_SINGLE, "WOCKY_DATA_FORM_FIELD_TYPE_TEXT_SINGLE", "text-single" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyDataFormFieldType", values);
  }
  return etype;
}
GType
wocky_data_form_error_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_DATA_FORM_ERROR_NOT_FORM, "WOCKY_DATA_FORM_ERROR_NOT_FORM", "not-form" },
      { WOCKY_DATA_FORM_ERROR_WRONG_TYPE, "WOCKY_DATA_FORM_ERROR_WRONG_TYPE", "wrong-type" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyDataFormError", values);
  }
  return etype;
}

/* enumerations from "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-jingle-info-internal.h" */
#include "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-jingle-info-internal.h"
GType
wocky_stun_server_source_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_STUN_SERVER_USER_SPECIFIED, "WOCKY_STUN_SERVER_USER_SPECIFIED", "user-specified" },
      { WOCKY_STUN_SERVER_DISCOVERED, "WOCKY_STUN_SERVER_DISCOVERED", "discovered" },
      { WOCKY_STUN_SERVER_FALLBACK, "WOCKY_STUN_SERVER_FALLBACK", "fallback" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyStunServerSource", values);
  }
  return etype;
}

/* enumerations from "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-jingle-types.h" */
#include "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-jingle-types.h"
GType
wocky_jingle_reason_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_JINGLE_REASON_UNKNOWN, "WOCKY_JINGLE_REASON_UNKNOWN", "unknown" },
      { WOCKY_JINGLE_REASON_ALTERNATIVE_SESSION, "WOCKY_JINGLE_REASON_ALTERNATIVE_SESSION", "alternative-session" },
      { WOCKY_JINGLE_REASON_BUSY, "WOCKY_JINGLE_REASON_BUSY", "busy" },
      { WOCKY_JINGLE_REASON_CANCEL, "WOCKY_JINGLE_REASON_CANCEL", "cancel" },
      { WOCKY_JINGLE_REASON_CONNECTIVITY_ERROR, "WOCKY_JINGLE_REASON_CONNECTIVITY_ERROR", "connectivity-error" },
      { WOCKY_JINGLE_REASON_DECLINE, "WOCKY_JINGLE_REASON_DECLINE", "decline" },
      { WOCKY_JINGLE_REASON_EXPIRED, "WOCKY_JINGLE_REASON_EXPIRED", "expired" },
      { WOCKY_JINGLE_REASON_FAILED_APPLICATION, "WOCKY_JINGLE_REASON_FAILED_APPLICATION", "failed-application" },
      { WOCKY_JINGLE_REASON_FAILED_TRANSPORT, "WOCKY_JINGLE_REASON_FAILED_TRANSPORT", "failed-transport" },
      { WOCKY_JINGLE_REASON_GENERAL_ERROR, "WOCKY_JINGLE_REASON_GENERAL_ERROR", "general-error" },
      { WOCKY_JINGLE_REASON_GONE, "WOCKY_JINGLE_REASON_GONE", "gone" },
      { WOCKY_JINGLE_REASON_INCOMPATIBLE_PARAMETERS, "WOCKY_JINGLE_REASON_INCOMPATIBLE_PARAMETERS", "incompatible-parameters" },
      { WOCKY_JINGLE_REASON_MEDIA_ERROR, "WOCKY_JINGLE_REASON_MEDIA_ERROR", "media-error" },
      { WOCKY_JINGLE_REASON_SECURITY_ERROR, "WOCKY_JINGLE_REASON_SECURITY_ERROR", "security-error" },
      { WOCKY_JINGLE_REASON_SUCCESS, "WOCKY_JINGLE_REASON_SUCCESS", "success" },
      { WOCKY_JINGLE_REASON_TIMEOUT, "WOCKY_JINGLE_REASON_TIMEOUT", "timeout" },
      { WOCKY_JINGLE_REASON_UNSUPPORTED_APPLICATIONS, "WOCKY_JINGLE_REASON_UNSUPPORTED_APPLICATIONS", "unsupported-applications" },
      { WOCKY_JINGLE_REASON_UNSUPPORTED_TRANSPORTS, "WOCKY_JINGLE_REASON_UNSUPPORTED_TRANSPORTS", "unsupported-transports" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyJingleReason", values);
  }
  return etype;
}

/* enumerations from "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-muc.h" */
#include "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-muc.h"
GType
wocky_muc_status_code_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GFlagsValue values[] = {
      { WOCKY_MUC_CODE_UNKNOWN, "WOCKY_MUC_CODE_UNKNOWN", "unknown" },
      { WOCKY_MUC_CODE_ONYMOUS, "WOCKY_MUC_CODE_ONYMOUS", "onymous" },
      { WOCKY_MUC_CODE_AF_CHANGE_OOB, "WOCKY_MUC_CODE_AF_CHANGE_OOB", "af-change-oob" },
      { WOCKY_MUC_CODE_CFG_SHOW_UNAVAILABLE, "WOCKY_MUC_CODE_CFG_SHOW_UNAVAILABLE", "cfg-show-unavailable" },
      { WOCKY_MUC_CODE_CFG_HIDE_UNAVAILABLE, "WOCKY_MUC_CODE_CFG_HIDE_UNAVAILABLE", "cfg-hide-unavailable" },
      { WOCKY_MUC_CODE_CFG_NONPRIVACY, "WOCKY_MUC_CODE_CFG_NONPRIVACY", "cfg-nonprivacy" },
      { WOCKY_MUC_CODE_OWN_PRESENCE, "WOCKY_MUC_CODE_OWN_PRESENCE", "own-presence" },
      { WOCKY_MUC_CODE_CFG_LOGGING_ENABLED, "WOCKY_MUC_CODE_CFG_LOGGING_ENABLED", "cfg-logging-enabled" },
      { WOCKY_MUC_CODE_CFG_LOGGING_DISABLED, "WOCKY_MUC_CODE_CFG_LOGGING_DISABLED", "cfg-logging-disabled" },
      { WOCKY_MUC_CODE_CFG_ONYMOUS, "WOCKY_MUC_CODE_CFG_ONYMOUS", "cfg-onymous" },
      { WOCKY_MUC_CODE_CFG_SEMIONYMOUS, "WOCKY_MUC_CODE_CFG_SEMIONYMOUS", "cfg-semionymous" },
      { WOCKY_MUC_CODE_CFG_ANONYMOUS, "WOCKY_MUC_CODE_CFG_ANONYMOUS", "cfg-anonymous" },
      { WOCKY_MUC_CODE_NEW_ROOM, "WOCKY_MUC_CODE_NEW_ROOM", "new-room" },
      { WOCKY_MUC_CODE_NICK_CHANGE_FORCED, "WOCKY_MUC_CODE_NICK_CHANGE_FORCED", "nick-change-forced" },
      { WOCKY_MUC_CODE_BANNED, "WOCKY_MUC_CODE_BANNED", "banned" },
      { WOCKY_MUC_CODE_NICK_CHANGE_USER, "WOCKY_MUC_CODE_NICK_CHANGE_USER", "nick-change-user" },
      { WOCKY_MUC_CODE_KICKED, "WOCKY_MUC_CODE_KICKED", "kicked" },
      { WOCKY_MUC_CODE_KICKED_AFFILIATION, "WOCKY_MUC_CODE_KICKED_AFFILIATION", "kicked-affiliation" },
      { WOCKY_MUC_CODE_KICKED_ROOM_PRIVATISED, "WOCKY_MUC_CODE_KICKED_ROOM_PRIVATISED", "kicked-room-privatised" },
      { WOCKY_MUC_CODE_KICKED_SHUTDOWN, "WOCKY_MUC_CODE_KICKED_SHUTDOWN", "kicked-shutdown" },
      { 0, NULL, NULL }
    };
    etype = g_flags_register_static ("WockyMucStatusCode", values);
  }
  return etype;
}
GType
wocky_muc_role_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_MUC_ROLE_NONE, "WOCKY_MUC_ROLE_NONE", "none" },
      { WOCKY_MUC_ROLE_VISITOR, "WOCKY_MUC_ROLE_VISITOR", "visitor" },
      { WOCKY_MUC_ROLE_PARTICIPANT, "WOCKY_MUC_ROLE_PARTICIPANT", "participant" },
      { WOCKY_MUC_ROLE_MODERATOR, "WOCKY_MUC_ROLE_MODERATOR", "moderator" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyMucRole", values);
  }
  return etype;
}
GType
wocky_muc_affiliation_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_MUC_AFFILIATION_OUTCAST, "WOCKY_MUC_AFFILIATION_OUTCAST", "outcast" },
      { WOCKY_MUC_AFFILIATION_NONE, "WOCKY_MUC_AFFILIATION_NONE", "none" },
      { WOCKY_MUC_AFFILIATION_MEMBER, "WOCKY_MUC_AFFILIATION_MEMBER", "member" },
      { WOCKY_MUC_AFFILIATION_ADMIN, "WOCKY_MUC_AFFILIATION_ADMIN", "admin" },
      { WOCKY_MUC_AFFILIATION_OWNER, "WOCKY_MUC_AFFILIATION_OWNER", "owner" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyMucAffiliation", values);
  }
  return etype;
}
GType
wocky_muc_feature_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GFlagsValue values[] = {
      { WOCKY_MUC_MODERN, "WOCKY_MUC_MODERN", "modern" },
      { WOCKY_MUC_FORM_REGISTER, "WOCKY_MUC_FORM_REGISTER", "form-register" },
      { WOCKY_MUC_FORM_ROOMCONFIG, "WOCKY_MUC_FORM_ROOMCONFIG", "form-roomconfig" },
      { WOCKY_MUC_FORM_ROOMINFO, "WOCKY_MUC_FORM_ROOMINFO", "form-roominfo" },
      { WOCKY_MUC_HIDDEN, "WOCKY_MUC_HIDDEN", "hidden" },
      { WOCKY_MUC_MEMBERSONLY, "WOCKY_MUC_MEMBERSONLY", "membersonly" },
      { WOCKY_MUC_MODERATED, "WOCKY_MUC_MODERATED", "moderated" },
      { WOCKY_MUC_NONANONYMOUS, "WOCKY_MUC_NONANONYMOUS", "nonanonymous" },
      { WOCKY_MUC_OPEN, "WOCKY_MUC_OPEN", "open" },
      { WOCKY_MUC_PASSWORDPROTECTED, "WOCKY_MUC_PASSWORDPROTECTED", "passwordprotected" },
      { WOCKY_MUC_PERSISTENT, "WOCKY_MUC_PERSISTENT", "persistent" },
      { WOCKY_MUC_PUBLIC, "WOCKY_MUC_PUBLIC", "public" },
      { WOCKY_MUC_ROOMS, "WOCKY_MUC_ROOMS", "rooms" },
      { WOCKY_MUC_SEMIANONYMOUS, "WOCKY_MUC_SEMIANONYMOUS", "semianonymous" },
      { WOCKY_MUC_TEMPORARY, "WOCKY_MUC_TEMPORARY", "temporary" },
      { WOCKY_MUC_UNMODERATED, "WOCKY_MUC_UNMODERATED", "unmoderated" },
      { WOCKY_MUC_UNSECURED, "WOCKY_MUC_UNSECURED", "unsecured" },
      { WOCKY_MUC_OBSOLETE, "WOCKY_MUC_OBSOLETE", "obsolete" },
      { 0, NULL, NULL }
    };
    etype = g_flags_register_static ("WockyMucFeature", values);
  }
  return etype;
}
GType
wocky_muc_msg_type_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_MUC_MSG_NONE, "WOCKY_MUC_MSG_NONE", "none" },
      { WOCKY_MUC_MSG_NORMAL, "WOCKY_MUC_MSG_NORMAL", "normal" },
      { WOCKY_MUC_MSG_ACTION, "WOCKY_MUC_MSG_ACTION", "action" },
      { WOCKY_MUC_MSG_NOTICE, "WOCKY_MUC_MSG_NOTICE", "notice" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyMucMsgType", values);
  }
  return etype;
}
GType
wocky_muc_msg_state_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_MUC_MSG_STATE_NONE, "WOCKY_MUC_MSG_STATE_NONE", "none" },
      { WOCKY_MUC_MSG_STATE_ACTIVE, "WOCKY_MUC_MSG_STATE_ACTIVE", "active" },
      { WOCKY_MUC_MSG_STATE_COMPOSING, "WOCKY_MUC_MSG_STATE_COMPOSING", "composing" },
      { WOCKY_MUC_MSG_STATE_INACTIVE, "WOCKY_MUC_MSG_STATE_INACTIVE", "inactive" },
      { WOCKY_MUC_MSG_STATE_PAUSED, "WOCKY_MUC_MSG_STATE_PAUSED", "paused" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyMucMsgState", values);
  }
  return etype;
}
GType
wocky_muc_state_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_MUC_CREATED, "WOCKY_MUC_CREATED", "created" },
      { WOCKY_MUC_INITIATED, "WOCKY_MUC_INITIATED", "initiated" },
      { WOCKY_MUC_AUTH, "WOCKY_MUC_AUTH", "auth" },
      { WOCKY_MUC_JOINED, "WOCKY_MUC_JOINED", "joined" },
      { WOCKY_MUC_ENDED, "WOCKY_MUC_ENDED", "ended" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyMucState", values);
  }
  return etype;
}

/* enumerations from "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-pubsub-node.h" */
#include "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-pubsub-node.h"
GType
wocky_pubsub_affiliation_state_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_PUBSUB_AFFILIATION_OWNER, "WOCKY_PUBSUB_AFFILIATION_OWNER", "owner" },
      { WOCKY_PUBSUB_AFFILIATION_PUBLISHER, "WOCKY_PUBSUB_AFFILIATION_PUBLISHER", "publisher" },
      { WOCKY_PUBSUB_AFFILIATION_PUBLISH_ONLY, "WOCKY_PUBSUB_AFFILIATION_PUBLISH_ONLY", "publish-only" },
      { WOCKY_PUBSUB_AFFILIATION_MEMBER, "WOCKY_PUBSUB_AFFILIATION_MEMBER", "member" },
      { WOCKY_PUBSUB_AFFILIATION_NONE, "WOCKY_PUBSUB_AFFILIATION_NONE", "none" },
      { WOCKY_PUBSUB_AFFILIATION_OUTCAST, "WOCKY_PUBSUB_AFFILIATION_OUTCAST", "outcast" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyPubsubAffiliationState", values);
  }
  return etype;
}

/* enumerations from "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-pubsub-service.h" */
#include "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-pubsub-service.h"
GType
wocky_pubsub_service_error_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_PUBSUB_SERVICE_ERROR_WRONG_REPLY, "WOCKY_PUBSUB_SERVICE_ERROR_WRONG_REPLY", "reply" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyPubsubServiceError", values);
  }
  return etype;
}
GType
wocky_pubsub_subscription_state_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_PUBSUB_SUBSCRIPTION_NONE, "WOCKY_PUBSUB_SUBSCRIPTION_NONE", "none" },
      { WOCKY_PUBSUB_SUBSCRIPTION_PENDING, "WOCKY_PUBSUB_SUBSCRIPTION_PENDING", "pending" },
      { WOCKY_PUBSUB_SUBSCRIPTION_SUBSCRIBED, "WOCKY_PUBSUB_SUBSCRIPTION_SUBSCRIBED", "subscribed" },
      { WOCKY_PUBSUB_SUBSCRIPTION_UNCONFIGURED, "WOCKY_PUBSUB_SUBSCRIPTION_UNCONFIGURED", "unconfigured" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyPubsubSubscriptionState", values);
  }
  return etype;
}

/* enumerations from "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-tls.h" */
#include "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-tls.h"
GType
wocky_tls_verification_level_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_TLS_VERIFY_STRICT, "WOCKY_TLS_VERIFY_STRICT", "strict" },
      { WOCKY_TLS_VERIFY_NORMAL, "WOCKY_TLS_VERIFY_NORMAL", "normal" },
      { WOCKY_TLS_VERIFY_LENIENT, "WOCKY_TLS_VERIFY_LENIENT", "lenient" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyTLSVerificationLevel", values);
  }
  return etype;
}
GType
wocky_tls_cert_status_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_TLS_CERT_OK, "WOCKY_TLS_CERT_OK", "ok" },
      { WOCKY_TLS_CERT_INVALID, "WOCKY_TLS_CERT_INVALID", "invalid" },
      { WOCKY_TLS_CERT_NAME_MISMATCH, "WOCKY_TLS_CERT_NAME_MISMATCH", "name-mismatch" },
      { WOCKY_TLS_CERT_REVOKED, "WOCKY_TLS_CERT_REVOKED", "revoked" },
      { WOCKY_TLS_CERT_SIGNER_UNKNOWN, "WOCKY_TLS_CERT_SIGNER_UNKNOWN", "signer-unknown" },
      { WOCKY_TLS_CERT_SIGNER_UNAUTHORISED, "WOCKY_TLS_CERT_SIGNER_UNAUTHORISED", "signer-unauthorised" },
      { WOCKY_TLS_CERT_INSECURE, "WOCKY_TLS_CERT_INSECURE", "insecure" },
      { WOCKY_TLS_CERT_NOT_ACTIVE, "WOCKY_TLS_CERT_NOT_ACTIVE", "not-active" },
      { WOCKY_TLS_CERT_EXPIRED, "WOCKY_TLS_CERT_EXPIRED", "expired" },
      { WOCKY_TLS_CERT_NO_CERTIFICATE, "WOCKY_TLS_CERT_NO_CERTIFICATE", "no-certificate" },
      { WOCKY_TLS_CERT_MAYBE_DOS, "WOCKY_TLS_CERT_MAYBE_DOS", "maybe-dos" },
      { WOCKY_TLS_CERT_INTERNAL_ERROR, "WOCKY_TLS_CERT_INTERNAL_ERROR", "internal-error" },
      { WOCKY_TLS_CERT_UNKNOWN_ERROR, "WOCKY_TLS_CERT_UNKNOWN_ERROR", "unknown-error" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyTLSCertStatus", values);
  }
  return etype;
}
GType
wocky_tls_cert_type_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_TLS_CERT_TYPE_NONE, "WOCKY_TLS_CERT_TYPE_NONE", "none" },
      { WOCKY_TLS_CERT_TYPE_X509, "WOCKY_TLS_CERT_TYPE_X509", "x509" },
      { WOCKY_TLS_CERT_TYPE_OPENPGP, "WOCKY_TLS_CERT_TYPE_OPENPGP", "openpgp" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyTLSCertType", values);
  }
  return etype;
}

/* enumerations from "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-xmpp-error.h" */
#include "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-xmpp-error.h"
GType
wocky_xmpp_error_type_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_XMPP_ERROR_TYPE_CANCEL, "WOCKY_XMPP_ERROR_TYPE_CANCEL", "cancel" },
      { WOCKY_XMPP_ERROR_TYPE_CONTINUE, "WOCKY_XMPP_ERROR_TYPE_CONTINUE", "continue" },
      { WOCKY_XMPP_ERROR_TYPE_MODIFY, "WOCKY_XMPP_ERROR_TYPE_MODIFY", "modify" },
      { WOCKY_XMPP_ERROR_TYPE_AUTH, "WOCKY_XMPP_ERROR_TYPE_AUTH", "auth" },
      { WOCKY_XMPP_ERROR_TYPE_WAIT, "WOCKY_XMPP_ERROR_TYPE_WAIT", "wait" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyXmppErrorType", values);
  }
  return etype;
}
GType
wocky_xmpp_error_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_XMPP_ERROR_UNDEFINED_CONDITION, "WOCKY_XMPP_ERROR_UNDEFINED_CONDITION", "undefined-condition" },
      { WOCKY_XMPP_ERROR_REDIRECT, "WOCKY_XMPP_ERROR_REDIRECT", "redirect" },
      { WOCKY_XMPP_ERROR_GONE, "WOCKY_XMPP_ERROR_GONE", "gone" },
      { WOCKY_XMPP_ERROR_BAD_REQUEST, "WOCKY_XMPP_ERROR_BAD_REQUEST", "bad-request" },
      { WOCKY_XMPP_ERROR_UNEXPECTED_REQUEST, "WOCKY_XMPP_ERROR_UNEXPECTED_REQUEST", "unexpected-request" },
      { WOCKY_XMPP_ERROR_JID_MALFORMED, "WOCKY_XMPP_ERROR_JID_MALFORMED", "jid-malformed" },
      { WOCKY_XMPP_ERROR_NOT_AUTHORIZED, "WOCKY_XMPP_ERROR_NOT_AUTHORIZED", "not-authorized" },
      { WOCKY_XMPP_ERROR_PAYMENT_REQUIRED, "WOCKY_XMPP_ERROR_PAYMENT_REQUIRED", "payment-required" },
      { WOCKY_XMPP_ERROR_FORBIDDEN, "WOCKY_XMPP_ERROR_FORBIDDEN", "forbidden" },
      { WOCKY_XMPP_ERROR_ITEM_NOT_FOUND, "WOCKY_XMPP_ERROR_ITEM_NOT_FOUND", "item-not-found" },
      { WOCKY_XMPP_ERROR_RECIPIENT_UNAVAILABLE, "WOCKY_XMPP_ERROR_RECIPIENT_UNAVAILABLE", "recipient-unavailable" },
      { WOCKY_XMPP_ERROR_REMOTE_SERVER_NOT_FOUND, "WOCKY_XMPP_ERROR_REMOTE_SERVER_NOT_FOUND", "remote-server-not-found" },
      { WOCKY_XMPP_ERROR_NOT_ALLOWED, "WOCKY_XMPP_ERROR_NOT_ALLOWED", "not-allowed" },
      { WOCKY_XMPP_ERROR_NOT_ACCEPTABLE, "WOCKY_XMPP_ERROR_NOT_ACCEPTABLE", "not-acceptable" },
      { WOCKY_XMPP_ERROR_REGISTRATION_REQUIRED, "WOCKY_XMPP_ERROR_REGISTRATION_REQUIRED", "registration-required" },
      { WOCKY_XMPP_ERROR_SUBSCRIPTION_REQUIRED, "WOCKY_XMPP_ERROR_SUBSCRIPTION_REQUIRED", "subscription-required" },
      { WOCKY_XMPP_ERROR_REMOTE_SERVER_TIMEOUT, "WOCKY_XMPP_ERROR_REMOTE_SERVER_TIMEOUT", "remote-server-timeout" },
      { WOCKY_XMPP_ERROR_CONFLICT, "WOCKY_XMPP_ERROR_CONFLICT", "conflict" },
      { WOCKY_XMPP_ERROR_INTERNAL_SERVER_ERROR, "WOCKY_XMPP_ERROR_INTERNAL_SERVER_ERROR", "internal-server-error" },
      { WOCKY_XMPP_ERROR_RESOURCE_CONSTRAINT, "WOCKY_XMPP_ERROR_RESOURCE_CONSTRAINT", "resource-constraint" },
      { WOCKY_XMPP_ERROR_FEATURE_NOT_IMPLEMENTED, "WOCKY_XMPP_ERROR_FEATURE_NOT_IMPLEMENTED", "feature-not-implemented" },
      { WOCKY_XMPP_ERROR_SERVICE_UNAVAILABLE, "WOCKY_XMPP_ERROR_SERVICE_UNAVAILABLE", "service-unavailable" },
      { WOCKY_XMPP_ERROR_POLICY_VIOLATION, "WOCKY_XMPP_ERROR_POLICY_VIOLATION", "policy-violation" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyXmppError", values);
  }
  return etype;
}
GType
wocky_jingle_error_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_JINGLE_ERROR_OUT_OF_ORDER, "WOCKY_JINGLE_ERROR_OUT_OF_ORDER", "out-of-order" },
      { WOCKY_JINGLE_ERROR_TIE_BREAK, "WOCKY_JINGLE_ERROR_TIE_BREAK", "tie-break" },
      { WOCKY_JINGLE_ERROR_UNKNOWN_SESSION, "WOCKY_JINGLE_ERROR_UNKNOWN_SESSION", "unknown-session" },
      { WOCKY_JINGLE_ERROR_UNSUPPORTED_INFO, "WOCKY_JINGLE_ERROR_UNSUPPORTED_INFO", "unsupported-info" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyJingleError", values);
  }
  return etype;
}
GType
wocky_si_error_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_SI_ERROR_NO_VALID_STREAMS, "WOCKY_SI_ERROR_NO_VALID_STREAMS", "no-valid-streams" },
      { WOCKY_SI_ERROR_BAD_PROFILE, "WOCKY_SI_ERROR_BAD_PROFILE", "bad-profile" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockySIError", values);
  }
  return etype;
}
GType
wocky_xmpp_stream_error_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_XMPP_STREAM_ERROR_BAD_FORMAT, "WOCKY_XMPP_STREAM_ERROR_BAD_FORMAT", "bad-format" },
      { WOCKY_XMPP_STREAM_ERROR_BAD_NAMESPACE_PREFIX, "WOCKY_XMPP_STREAM_ERROR_BAD_NAMESPACE_PREFIX", "bad-namespace-prefix" },
      { WOCKY_XMPP_STREAM_ERROR_CONFLICT, "WOCKY_XMPP_STREAM_ERROR_CONFLICT", "conflict" },
      { WOCKY_XMPP_STREAM_ERROR_CONNECTION_TIMEOUT, "WOCKY_XMPP_STREAM_ERROR_CONNECTION_TIMEOUT", "connection-timeout" },
      { WOCKY_XMPP_STREAM_ERROR_HOST_GONE, "WOCKY_XMPP_STREAM_ERROR_HOST_GONE", "host-gone" },
      { WOCKY_XMPP_STREAM_ERROR_HOST_UNKNOWN, "WOCKY_XMPP_STREAM_ERROR_HOST_UNKNOWN", "host-unknown" },
      { WOCKY_XMPP_STREAM_ERROR_IMPROPER_ADDRESSING, "WOCKY_XMPP_STREAM_ERROR_IMPROPER_ADDRESSING", "improper-addressing" },
      { WOCKY_XMPP_STREAM_ERROR_INTERNAL_SERVER_ERROR, "WOCKY_XMPP_STREAM_ERROR_INTERNAL_SERVER_ERROR", "internal-server-error" },
      { WOCKY_XMPP_STREAM_ERROR_INVALID_FROM, "WOCKY_XMPP_STREAM_ERROR_INVALID_FROM", "invalid-from" },
      { WOCKY_XMPP_STREAM_ERROR_INVALID_ID, "WOCKY_XMPP_STREAM_ERROR_INVALID_ID", "invalid-id" },
      { WOCKY_XMPP_STREAM_ERROR_INVALID_NAMESPACE, "WOCKY_XMPP_STREAM_ERROR_INVALID_NAMESPACE", "invalid-namespace" },
      { WOCKY_XMPP_STREAM_ERROR_INVALID_XML, "WOCKY_XMPP_STREAM_ERROR_INVALID_XML", "invalid-xml" },
      { WOCKY_XMPP_STREAM_ERROR_NOT_AUTHORIZED, "WOCKY_XMPP_STREAM_ERROR_NOT_AUTHORIZED", "not-authorized" },
      { WOCKY_XMPP_STREAM_ERROR_POLICY_VIOLATION, "WOCKY_XMPP_STREAM_ERROR_POLICY_VIOLATION", "policy-violation" },
      { WOCKY_XMPP_STREAM_ERROR_REMOTE_CONNECTION_FAILED, "WOCKY_XMPP_STREAM_ERROR_REMOTE_CONNECTION_FAILED", "remote-connection-failed" },
      { WOCKY_XMPP_STREAM_ERROR_RESOURCE_CONSTRAINT, "WOCKY_XMPP_STREAM_ERROR_RESOURCE_CONSTRAINT", "resource-constraint" },
      { WOCKY_XMPP_STREAM_ERROR_RESTRICTED_XML, "WOCKY_XMPP_STREAM_ERROR_RESTRICTED_XML", "restricted-xml" },
      { WOCKY_XMPP_STREAM_ERROR_SEE_OTHER_HOST, "WOCKY_XMPP_STREAM_ERROR_SEE_OTHER_HOST", "see-other-host" },
      { WOCKY_XMPP_STREAM_ERROR_SYSTEM_SHUTDOWN, "WOCKY_XMPP_STREAM_ERROR_SYSTEM_SHUTDOWN", "system-shutdown" },
      { WOCKY_XMPP_STREAM_ERROR_UNDEFINED_CONDITION, "WOCKY_XMPP_STREAM_ERROR_UNDEFINED_CONDITION", "undefined-condition" },
      { WOCKY_XMPP_STREAM_ERROR_UNSUPPORTED_ENCODING, "WOCKY_XMPP_STREAM_ERROR_UNSUPPORTED_ENCODING", "unsupported-encoding" },
      { WOCKY_XMPP_STREAM_ERROR_UNSUPPORTED_STANZA_TYPE, "WOCKY_XMPP_STREAM_ERROR_UNSUPPORTED_STANZA_TYPE", "unsupported-stanza-type" },
      { WOCKY_XMPP_STREAM_ERROR_UNSUPPORTED_VERSION, "WOCKY_XMPP_STREAM_ERROR_UNSUPPORTED_VERSION", "unsupported-version" },
      { WOCKY_XMPP_STREAM_ERROR_XML_NOT_WELL_FORMED, "WOCKY_XMPP_STREAM_ERROR_XML_NOT_WELL_FORMED", "xml-not-well-formed" },
      { WOCKY_XMPP_STREAM_ERROR_UNKNOWN, "WOCKY_XMPP_STREAM_ERROR_UNKNOWN", "unknown" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyXmppStreamError", values);
  }
  return etype;
}

/* enumerations from "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-xmpp-reader.h" */
#include "/usr/src/ports/telepathy-gabble/telepathy-gabble-0.18.4-1.i686/src/telepathy-gabble-0.18.4/lib/ext/wocky/wocky/wocky-xmpp-reader.h"
GType
wocky_xmpp_reader_state_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_XMPP_READER_STATE_INITIAL, "WOCKY_XMPP_READER_STATE_INITIAL", "initial" },
      { WOCKY_XMPP_READER_STATE_OPENED, "WOCKY_XMPP_READER_STATE_OPENED", "opened" },
      { WOCKY_XMPP_READER_STATE_CLOSED, "WOCKY_XMPP_READER_STATE_CLOSED", "closed" },
      { WOCKY_XMPP_READER_STATE_ERROR, "WOCKY_XMPP_READER_STATE_ERROR", "error" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyXmppReaderState", values);
  }
  return etype;
}
GType
wocky_xmpp_reader_error_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { WOCKY_XMPP_READER_ERROR_INVALID_STREAM_START, "WOCKY_XMPP_READER_ERROR_INVALID_STREAM_START", "invalid-stream-start" },
      { WOCKY_XMPP_READER_ERROR_PARSE_ERROR, "WOCKY_XMPP_READER_ERROR_PARSE_ERROR", "parse-error" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("WockyXmppReaderError", values);
  }
  return etype;
}



