
/* Generated data (by glib-mkenums) */

#include <libvirt-gconfig/libvirt-gconfig.h>

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain.h" */
GType
gvir_config_domain_virt_type_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_VIRT_QEMU, "GVIR_CONFIG_DOMAIN_VIRT_QEMU", "qemu" },
        { GVIR_CONFIG_DOMAIN_VIRT_KQEMU, "GVIR_CONFIG_DOMAIN_VIRT_KQEMU", "kqemu" },
        { GVIR_CONFIG_DOMAIN_VIRT_KVM, "GVIR_CONFIG_DOMAIN_VIRT_KVM", "kvm" },
        { GVIR_CONFIG_DOMAIN_VIRT_XEN, "GVIR_CONFIG_DOMAIN_VIRT_XEN", "xen" },
        { GVIR_CONFIG_DOMAIN_VIRT_LXC, "GVIR_CONFIG_DOMAIN_VIRT_LXC", "lxc" },
        { GVIR_CONFIG_DOMAIN_VIRT_UML, "GVIR_CONFIG_DOMAIN_VIRT_UML", "uml" },
        { GVIR_CONFIG_DOMAIN_VIRT_OPENVZ, "GVIR_CONFIG_DOMAIN_VIRT_OPENVZ", "openvz" },
        { GVIR_CONFIG_DOMAIN_VIRT_VSERVER, "GVIR_CONFIG_DOMAIN_VIRT_VSERVER", "vserver" },
        { GVIR_CONFIG_DOMAIN_VIRT_LDOM, "GVIR_CONFIG_DOMAIN_VIRT_LDOM", "ldom" },
        { GVIR_CONFIG_DOMAIN_VIRT_TEST, "GVIR_CONFIG_DOMAIN_VIRT_TEST", "test" },
        { GVIR_CONFIG_DOMAIN_VIRT_VMWARE, "GVIR_CONFIG_DOMAIN_VIRT_VMWARE", "vmware" },
        { GVIR_CONFIG_DOMAIN_VIRT_HYPERV, "GVIR_CONFIG_DOMAIN_VIRT_HYPERV", "hyperv" },
        { GVIR_CONFIG_DOMAIN_VIRT_VBOX, "GVIR_CONFIG_DOMAIN_VIRT_VBOX", "vbox" },
        { GVIR_CONFIG_DOMAIN_VIRT_ONE, "GVIR_CONFIG_DOMAIN_VIRT_ONE", "one" },
        { GVIR_CONFIG_DOMAIN_VIRT_PHYP, "GVIR_CONFIG_DOMAIN_VIRT_PHYP", "phyp" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainVirtType"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

GType
gvir_config_domain_lifecycle_event_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_LIFECYCLE_ON_POWEROFF, "GVIR_CONFIG_DOMAIN_LIFECYCLE_ON_POWEROFF", "on_poweroff" },
        { GVIR_CONFIG_DOMAIN_LIFECYCLE_ON_REBOOT, "GVIR_CONFIG_DOMAIN_LIFECYCLE_ON_REBOOT", "on_reboot" },
        { GVIR_CONFIG_DOMAIN_LIFECYCLE_ON_CRASH, "GVIR_CONFIG_DOMAIN_LIFECYCLE_ON_CRASH", "on_crash" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainLifecycleEvent"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

GType
gvir_config_domain_lifecycle_action_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_LIFECYCLE_DESTROY, "GVIR_CONFIG_DOMAIN_LIFECYCLE_DESTROY", "destroy" },
        { GVIR_CONFIG_DOMAIN_LIFECYCLE_RESTART, "GVIR_CONFIG_DOMAIN_LIFECYCLE_RESTART", "restart" },
        { GVIR_CONFIG_DOMAIN_LIFECYCLE_PRESERVE, "GVIR_CONFIG_DOMAIN_LIFECYCLE_PRESERVE", "preserve" },
        { GVIR_CONFIG_DOMAIN_LIFECYCLE_RENAME_RESTART, "GVIR_CONFIG_DOMAIN_LIFECYCLE_RENAME_RESTART", "rename-restart" },
        { GVIR_CONFIG_DOMAIN_LIFECYCLE_COREDUMP_DESTROY, "GVIR_CONFIG_DOMAIN_LIFECYCLE_COREDUMP_DESTROY", "coredump-destroy" },
        { GVIR_CONFIG_DOMAIN_LIFECYCLE_COREDUMP_RESTART, "GVIR_CONFIG_DOMAIN_LIFECYCLE_COREDUMP_RESTART", "coredump-restart" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainLifecycleAction"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain-channel.h" */
GType
gvir_config_domain_channel_target_type_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_CHANNEL_TARGET_GUESTFWD, "GVIR_CONFIG_DOMAIN_CHANNEL_TARGET_GUESTFWD", "guestfwd" },
        { GVIR_CONFIG_DOMAIN_CHANNEL_TARGET_VIRTIO, "GVIR_CONFIG_DOMAIN_CHANNEL_TARGET_VIRTIO", "virtio" },
        { GVIR_CONFIG_DOMAIN_CHANNEL_TARGET_SPICEPORT, "GVIR_CONFIG_DOMAIN_CHANNEL_TARGET_SPICEPORT", "spiceport" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainChannelTargetType"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain-clock.h" */
GType
gvir_config_domain_clock_offset_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_CLOCK_UTC, "GVIR_CONFIG_DOMAIN_CLOCK_UTC", "utc" },
        { GVIR_CONFIG_DOMAIN_CLOCK_LOCALTIME, "GVIR_CONFIG_DOMAIN_CLOCK_LOCALTIME", "localtime" },
        { GVIR_CONFIG_DOMAIN_CLOCK_TIMEZONE, "GVIR_CONFIG_DOMAIN_CLOCK_TIMEZONE", "timezone" },
        { GVIR_CONFIG_DOMAIN_CLOCK_VARIABLE, "GVIR_CONFIG_DOMAIN_CLOCK_VARIABLE", "variable" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainClockOffset"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain-console.h" */
GType
gvir_config_domain_console_target_type_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_CONSOLE_TARGET_XEN, "GVIR_CONFIG_DOMAIN_CONSOLE_TARGET_XEN", "xen" },
        { GVIR_CONFIG_DOMAIN_CONSOLE_TARGET_SERIAL, "GVIR_CONFIG_DOMAIN_CONSOLE_TARGET_SERIAL", "serial" },
        { GVIR_CONFIG_DOMAIN_CONSOLE_TARGET_UML, "GVIR_CONFIG_DOMAIN_CONSOLE_TARGET_UML", "uml" },
        { GVIR_CONFIG_DOMAIN_CONSOLE_TARGET_VIRTIO, "GVIR_CONFIG_DOMAIN_CONSOLE_TARGET_VIRTIO", "virtio" },
        { GVIR_CONFIG_DOMAIN_CONSOLE_TARGET_LXC, "GVIR_CONFIG_DOMAIN_CONSOLE_TARGET_LXC", "lxc" },
        { GVIR_CONFIG_DOMAIN_CONSOLE_TARGET_OPENVZ, "GVIR_CONFIG_DOMAIN_CONSOLE_TARGET_OPENVZ", "openvz" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainConsoleTargetType"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain-controller-usb.h" */
GType
gvir_config_domain_controller_usb_model_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_PIIX3_UHCI, "GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_PIIX3_UHCI", "piix3-uhci" },
        { GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_PIIX4_UHCI, "GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_PIIX4_UHCI", "piix4-uhci" },
        { GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_EHCI, "GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_EHCI", "ehci" },
        { GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_ICH9_EHCI1, "GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_ICH9_EHCI1", "ich9-ehci1" },
        { GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_ICH9_UHCI1, "GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_ICH9_UHCI1", "ich9-uhci1" },
        { GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_ICH9_UHCI2, "GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_ICH9_UHCI2", "ich9-uhci2" },
        { GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_ICH9_UHCI3, "GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_ICH9_UHCI3", "ich9-uhci3" },
        { GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_VT82C686B_UHCI, "GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_VT82C686B_UHCI", "vt82c686b-uhci" },
        { GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_PCI_OHCI, "GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_PCI_OHCI", "pci-ohci" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainControllerUsbModel"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain-cpu.h" */
GType
gvir_config_domain_cpu_match_policy_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_CPU_MATCH_POLICY_MINIMUM, "GVIR_CONFIG_DOMAIN_CPU_MATCH_POLICY_MINIMUM", "minimum" },
        { GVIR_CONFIG_DOMAIN_CPU_MATCH_POLICY_EXACT, "GVIR_CONFIG_DOMAIN_CPU_MATCH_POLICY_EXACT", "exact" },
        { GVIR_CONFIG_DOMAIN_CPU_MATCH_POLICY_STRICT, "GVIR_CONFIG_DOMAIN_CPU_MATCH_POLICY_STRICT", "strict" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainCpuMatchPolicy"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

GType
gvir_config_domain_cpu_mode_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_CPU_MODE_CUSTOM, "GVIR_CONFIG_DOMAIN_CPU_MODE_CUSTOM", "custom" },
        { GVIR_CONFIG_DOMAIN_CPU_MODE_HOST_MODEL, "GVIR_CONFIG_DOMAIN_CPU_MODE_HOST_MODEL", "host-model" },
        { GVIR_CONFIG_DOMAIN_CPU_MODE_HOST_PASSTHROUGH, "GVIR_CONFIG_DOMAIN_CPU_MODE_HOST_PASSTHROUGH", "host-passthrough" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainCpuMode"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain-cpu-feature.h" */
GType
gvir_config_domain_cpu_feature_policy_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_CPU_FEATURE_POLICY_FORCE, "GVIR_CONFIG_DOMAIN_CPU_FEATURE_POLICY_FORCE", "force" },
        { GVIR_CONFIG_DOMAIN_CPU_FEATURE_POLICY_REQUIRE, "GVIR_CONFIG_DOMAIN_CPU_FEATURE_POLICY_REQUIRE", "require" },
        { GVIR_CONFIG_DOMAIN_CPU_FEATURE_POLICY_OPTIONAL, "GVIR_CONFIG_DOMAIN_CPU_FEATURE_POLICY_OPTIONAL", "optional" },
        { GVIR_CONFIG_DOMAIN_CPU_FEATURE_POLICY_DISABLE, "GVIR_CONFIG_DOMAIN_CPU_FEATURE_POLICY_DISABLE", "disable" },
        { GVIR_CONFIG_DOMAIN_CPU_FEATURE_POLICY_FORBID, "GVIR_CONFIG_DOMAIN_CPU_FEATURE_POLICY_FORBID", "forbid" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainCpuFeaturePolicy"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain-disk.h" */
GType
gvir_config_domain_disk_type_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_DISK_FILE, "GVIR_CONFIG_DOMAIN_DISK_FILE", "file" },
        { GVIR_CONFIG_DOMAIN_DISK_BLOCK, "GVIR_CONFIG_DOMAIN_DISK_BLOCK", "block" },
        { GVIR_CONFIG_DOMAIN_DISK_DIR, "GVIR_CONFIG_DOMAIN_DISK_DIR", "dir" },
        { GVIR_CONFIG_DOMAIN_DISK_NETWORK, "GVIR_CONFIG_DOMAIN_DISK_NETWORK", "network" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainDiskType"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

GType
gvir_config_domain_disk_bus_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_DISK_BUS_IDE, "GVIR_CONFIG_DOMAIN_DISK_BUS_IDE", "ide" },
        { GVIR_CONFIG_DOMAIN_DISK_BUS_FDC, "GVIR_CONFIG_DOMAIN_DISK_BUS_FDC", "fdc" },
        { GVIR_CONFIG_DOMAIN_DISK_BUS_SCSI, "GVIR_CONFIG_DOMAIN_DISK_BUS_SCSI", "scsi" },
        { GVIR_CONFIG_DOMAIN_DISK_BUS_VIRTIO, "GVIR_CONFIG_DOMAIN_DISK_BUS_VIRTIO", "virtio" },
        { GVIR_CONFIG_DOMAIN_DISK_BUS_XEN, "GVIR_CONFIG_DOMAIN_DISK_BUS_XEN", "xen" },
        { GVIR_CONFIG_DOMAIN_DISK_BUS_USB, "GVIR_CONFIG_DOMAIN_DISK_BUS_USB", "usb" },
        { GVIR_CONFIG_DOMAIN_DISK_BUS_UML, "GVIR_CONFIG_DOMAIN_DISK_BUS_UML", "uml" },
        { GVIR_CONFIG_DOMAIN_DISK_BUS_SATA, "GVIR_CONFIG_DOMAIN_DISK_BUS_SATA", "sata" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainDiskBus"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

GType
gvir_config_domain_disk_guest_device_type_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_DISK_GUEST_DEVICE_DISK, "GVIR_CONFIG_DOMAIN_DISK_GUEST_DEVICE_DISK", "disk" },
        { GVIR_CONFIG_DOMAIN_DISK_GUEST_DEVICE_FLOPPY, "GVIR_CONFIG_DOMAIN_DISK_GUEST_DEVICE_FLOPPY", "floppy" },
        { GVIR_CONFIG_DOMAIN_DISK_GUEST_DEVICE_CDROM, "GVIR_CONFIG_DOMAIN_DISK_GUEST_DEVICE_CDROM", "cdrom" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainDiskGuestDeviceType"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

GType
gvir_config_domain_disk_snapshot_type_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_DISK_SNAPSHOT_NO, "GVIR_CONFIG_DOMAIN_DISK_SNAPSHOT_NO", "no" },
        { GVIR_CONFIG_DOMAIN_DISK_SNAPSHOT_INTERNAL, "GVIR_CONFIG_DOMAIN_DISK_SNAPSHOT_INTERNAL", "internal" },
        { GVIR_CONFIG_DOMAIN_DISK_SNAPSHOT_EXTERNAL, "GVIR_CONFIG_DOMAIN_DISK_SNAPSHOT_EXTERNAL", "external" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainDiskSnapshotType"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

GType
gvir_config_domain_disk_startup_policy_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_DISK_STARTUP_POLICY_MANDATORY, "GVIR_CONFIG_DOMAIN_DISK_STARTUP_POLICY_MANDATORY", "mandatory" },
        { GVIR_CONFIG_DOMAIN_DISK_STARTUP_POLICY_REQUISITE, "GVIR_CONFIG_DOMAIN_DISK_STARTUP_POLICY_REQUISITE", "requisite" },
        { GVIR_CONFIG_DOMAIN_DISK_STARTUP_POLICY_OPTIONAL, "GVIR_CONFIG_DOMAIN_DISK_STARTUP_POLICY_OPTIONAL", "optional" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainDiskStartupPolicy"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain-disk-driver.h" */
GType
gvir_config_domain_disk_cache_type_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_DISK_CACHE_DEFAULT, "GVIR_CONFIG_DOMAIN_DISK_CACHE_DEFAULT", "default" },
        { GVIR_CONFIG_DOMAIN_DISK_CACHE_NONE, "GVIR_CONFIG_DOMAIN_DISK_CACHE_NONE", "none" },
        { GVIR_CONFIG_DOMAIN_DISK_CACHE_WRITETHROUGH, "GVIR_CONFIG_DOMAIN_DISK_CACHE_WRITETHROUGH", "writethrough" },
        { GVIR_CONFIG_DOMAIN_DISK_CACHE_WRITEBACK, "GVIR_CONFIG_DOMAIN_DISK_CACHE_WRITEBACK", "writeback" },
        { GVIR_CONFIG_DOMAIN_DISK_CACHE_DIRECTSYNC, "GVIR_CONFIG_DOMAIN_DISK_CACHE_DIRECTSYNC", "directsync" },
        { GVIR_CONFIG_DOMAIN_DISK_CACHE_UNSAFE, "GVIR_CONFIG_DOMAIN_DISK_CACHE_UNSAFE", "unsafe" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainDiskCacheType"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

GType
gvir_config_domain_disk_format_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_DISK_FORMAT_RAW, "GVIR_CONFIG_DOMAIN_DISK_FORMAT_RAW", "raw" },
        { GVIR_CONFIG_DOMAIN_DISK_FORMAT_DIR, "GVIR_CONFIG_DOMAIN_DISK_FORMAT_DIR", "dir" },
        { GVIR_CONFIG_DOMAIN_DISK_FORMAT_BOCHS, "GVIR_CONFIG_DOMAIN_DISK_FORMAT_BOCHS", "bochs" },
        { GVIR_CONFIG_DOMAIN_DISK_FORMAT_CLOOP, "GVIR_CONFIG_DOMAIN_DISK_FORMAT_CLOOP", "cloop" },
        { GVIR_CONFIG_DOMAIN_DISK_FORMAT_COW, "GVIR_CONFIG_DOMAIN_DISK_FORMAT_COW", "cow" },
        { GVIR_CONFIG_DOMAIN_DISK_FORMAT_DMG, "GVIR_CONFIG_DOMAIN_DISK_FORMAT_DMG", "dmg" },
        { GVIR_CONFIG_DOMAIN_DISK_FORMAT_ISO, "GVIR_CONFIG_DOMAIN_DISK_FORMAT_ISO", "iso" },
        { GVIR_CONFIG_DOMAIN_DISK_FORMAT_QCOW, "GVIR_CONFIG_DOMAIN_DISK_FORMAT_QCOW", "qcow" },
        { GVIR_CONFIG_DOMAIN_DISK_FORMAT_QCOW2, "GVIR_CONFIG_DOMAIN_DISK_FORMAT_QCOW2", "qcow2" },
        { GVIR_CONFIG_DOMAIN_DISK_FORMAT_QED, "GVIR_CONFIG_DOMAIN_DISK_FORMAT_QED", "qed" },
        { GVIR_CONFIG_DOMAIN_DISK_FORMAT_VMDK, "GVIR_CONFIG_DOMAIN_DISK_FORMAT_VMDK", "vmdk" },
        { GVIR_CONFIG_DOMAIN_DISK_FORMAT_VPC, "GVIR_CONFIG_DOMAIN_DISK_FORMAT_VPC", "vpc" },
        { GVIR_CONFIG_DOMAIN_DISK_FORMAT_FAT, "GVIR_CONFIG_DOMAIN_DISK_FORMAT_FAT", "fat" },
        { GVIR_CONFIG_DOMAIN_DISK_FORMAT_VHD, "GVIR_CONFIG_DOMAIN_DISK_FORMAT_VHD", "vhd" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainDiskFormat"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

GType
gvir_config_domain_disk_driver_error_policy_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_DISK_DRIVER_ERROR_POLICY_STOP, "GVIR_CONFIG_DOMAIN_DISK_DRIVER_ERROR_POLICY_STOP", "stop" },
        { GVIR_CONFIG_DOMAIN_DISK_DRIVER_ERROR_POLICY_REPORT, "GVIR_CONFIG_DOMAIN_DISK_DRIVER_ERROR_POLICY_REPORT", "report" },
        { GVIR_CONFIG_DOMAIN_DISK_DRIVER_ERROR_POLICY_IGNORE, "GVIR_CONFIG_DOMAIN_DISK_DRIVER_ERROR_POLICY_IGNORE", "ignore" },
        { GVIR_CONFIG_DOMAIN_DISK_DRIVER_ERROR_POLICY_ENOSPACE, "GVIR_CONFIG_DOMAIN_DISK_DRIVER_ERROR_POLICY_ENOSPACE", "enospace" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainDiskDriverErrorPolicy"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

GType
gvir_config_domain_disk_driver_io_policy_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_DISK_DRIVER_IO_POLICY_THREADS, "GVIR_CONFIG_DOMAIN_DISK_DRIVER_IO_POLICY_THREADS", "threads" },
        { GVIR_CONFIG_DOMAIN_DISK_DRIVER_IO_POLICY_NATIVE, "GVIR_CONFIG_DOMAIN_DISK_DRIVER_IO_POLICY_NATIVE", "native" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainDiskDriverIoPolicy"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

GType
gvir_config_domain_disk_driver_discard_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_DISK_DRIVER_DISCARD_UNMAP, "GVIR_CONFIG_DOMAIN_DISK_DRIVER_DISCARD_UNMAP", "unmap" },
        { GVIR_CONFIG_DOMAIN_DISK_DRIVER_DISCARD_IGNORE, "GVIR_CONFIG_DOMAIN_DISK_DRIVER_DISCARD_IGNORE", "ignore" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainDiskDriverDiscard"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain-filesys.h" */
GType
gvir_config_domain_filesys_type_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_FILESYS_MOUNT, "GVIR_CONFIG_DOMAIN_FILESYS_MOUNT", "mount" },
        { GVIR_CONFIG_DOMAIN_FILESYS_BLOCK, "GVIR_CONFIG_DOMAIN_FILESYS_BLOCK", "block" },
        { GVIR_CONFIG_DOMAIN_FILESYS_FILE, "GVIR_CONFIG_DOMAIN_FILESYS_FILE", "file" },
        { GVIR_CONFIG_DOMAIN_FILESYS_TEMPLATE, "GVIR_CONFIG_DOMAIN_FILESYS_TEMPLATE", "template" },
        { GVIR_CONFIG_DOMAIN_FILESYS_RAM, "GVIR_CONFIG_DOMAIN_FILESYS_RAM", "ram" },
        { GVIR_CONFIG_DOMAIN_FILESYS_BIND, "GVIR_CONFIG_DOMAIN_FILESYS_BIND", "bind" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainFilesysType"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

GType
gvir_config_domain_filesys_access_type_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_FILESYS_ACCESS_PASSTHROUGH, "GVIR_CONFIG_DOMAIN_FILESYS_ACCESS_PASSTHROUGH", "passthrough" },
        { GVIR_CONFIG_DOMAIN_FILESYS_ACCESS_MAPPED, "GVIR_CONFIG_DOMAIN_FILESYS_ACCESS_MAPPED", "mapped" },
        { GVIR_CONFIG_DOMAIN_FILESYS_ACCESS_SQUASH, "GVIR_CONFIG_DOMAIN_FILESYS_ACCESS_SQUASH", "squash" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainFilesysAccessType"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

GType
gvir_config_domain_filesys_driver_type_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_FILESYS_DRIVER_DEFAULT, "GVIR_CONFIG_DOMAIN_FILESYS_DRIVER_DEFAULT", "default" },
        { GVIR_CONFIG_DOMAIN_FILESYS_DRIVER_PATH, "GVIR_CONFIG_DOMAIN_FILESYS_DRIVER_PATH", "path" },
        { GVIR_CONFIG_DOMAIN_FILESYS_DRIVER_HANDLE, "GVIR_CONFIG_DOMAIN_FILESYS_DRIVER_HANDLE", "handle" },
        { GVIR_CONFIG_DOMAIN_FILESYS_DRIVER_LOOP, "GVIR_CONFIG_DOMAIN_FILESYS_DRIVER_LOOP", "loop" },
        { GVIR_CONFIG_DOMAIN_FILESYS_DRIVER_NBD, "GVIR_CONFIG_DOMAIN_FILESYS_DRIVER_NBD", "nbd" },
        { GVIR_CONFIG_DOMAIN_FILESYS_DRIVER_PLOOP, "GVIR_CONFIG_DOMAIN_FILESYS_DRIVER_PLOOP", "ploop" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainFilesysDriverType"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain-graphics-spice.h" */
GType
gvir_config_domain_graphics_spice_image_compression_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_AUTO_GLZ, "GVIR_CONFIG_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_AUTO_GLZ", "auto_glz" },
        { GVIR_CONFIG_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_AUTO_LZ, "GVIR_CONFIG_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_AUTO_LZ", "auto_lz" },
        { GVIR_CONFIG_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_QUIC, "GVIR_CONFIG_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_QUIC", "quic" },
        { GVIR_CONFIG_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_GLZ, "GVIR_CONFIG_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_GLZ", "glz" },
        { GVIR_CONFIG_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_LZ, "GVIR_CONFIG_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_LZ", "lz" },
        { GVIR_CONFIG_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_OFF, "GVIR_CONFIG_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_OFF", "off" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainGraphicsSpiceImageCompression"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain-input.h" */
GType
gvir_config_domain_input_device_type_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_INPUT_DEVICE_MOUSE, "GVIR_CONFIG_DOMAIN_INPUT_DEVICE_MOUSE", "mouse" },
        { GVIR_CONFIG_DOMAIN_INPUT_DEVICE_TABLET, "GVIR_CONFIG_DOMAIN_INPUT_DEVICE_TABLET", "tablet" },
        { GVIR_CONFIG_DOMAIN_INPUT_DEVICE_KEYBOARD, "GVIR_CONFIG_DOMAIN_INPUT_DEVICE_KEYBOARD", "keyboard" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainInputDeviceType"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

GType
gvir_config_domain_input_bus_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_INPUT_BUS_PS2, "GVIR_CONFIG_DOMAIN_INPUT_BUS_PS2", "ps2" },
        { GVIR_CONFIG_DOMAIN_INPUT_BUS_USB, "GVIR_CONFIG_DOMAIN_INPUT_BUS_USB", "usb" },
        { GVIR_CONFIG_DOMAIN_INPUT_BUS_XEN, "GVIR_CONFIG_DOMAIN_INPUT_BUS_XEN", "xen" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainInputBus"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain-interface.h" */
GType
gvir_config_domain_interface_link_state_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_INTERFACE_LINK_STATE_DEFAULT, "GVIR_CONFIG_DOMAIN_INTERFACE_LINK_STATE_DEFAULT", "default" },
        { GVIR_CONFIG_DOMAIN_INTERFACE_LINK_STATE_UP, "GVIR_CONFIG_DOMAIN_INTERFACE_LINK_STATE_UP", "up" },
        { GVIR_CONFIG_DOMAIN_INTERFACE_LINK_STATE_DOWN, "GVIR_CONFIG_DOMAIN_INTERFACE_LINK_STATE_DOWN", "down" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainInterfaceLinkState"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain-memballoon.h" */
GType
gvir_config_domain_memballoon_model_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_MEMBALLOON_MODEL_NONE, "GVIR_CONFIG_DOMAIN_MEMBALLOON_MODEL_NONE", "none" },
        { GVIR_CONFIG_DOMAIN_MEMBALLOON_MODEL_VIRTIO, "GVIR_CONFIG_DOMAIN_MEMBALLOON_MODEL_VIRTIO", "virtio" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainMemballoonModel"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain-os.h" */
GType
gvir_config_domain_os_type_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_OS_TYPE_HVM, "GVIR_CONFIG_DOMAIN_OS_TYPE_HVM", "hvm" },
        { GVIR_CONFIG_DOMAIN_OS_TYPE_LINUX, "GVIR_CONFIG_DOMAIN_OS_TYPE_LINUX", "linux" },
        { GVIR_CONFIG_DOMAIN_OS_TYPE_EXE, "GVIR_CONFIG_DOMAIN_OS_TYPE_EXE", "exe" },
        { GVIR_CONFIG_DOMAIN_OS_TYPE_XEN, "GVIR_CONFIG_DOMAIN_OS_TYPE_XEN", "xen" },
        { GVIR_CONFIG_DOMAIN_OS_TYPE_UML, "GVIR_CONFIG_DOMAIN_OS_TYPE_UML", "uml" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainOsType"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

GType
gvir_config_domain_os_sm_bios_mode_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_OS_SMBIOS_MODE_EMULATE, "GVIR_CONFIG_DOMAIN_OS_SMBIOS_MODE_EMULATE", "emulate" },
        { GVIR_CONFIG_DOMAIN_OS_SMBIOS_MODE_HOST, "GVIR_CONFIG_DOMAIN_OS_SMBIOS_MODE_HOST", "host" },
        { GVIR_CONFIG_DOMAIN_OS_SMBIOS_MODE_SYSINFO, "GVIR_CONFIG_DOMAIN_OS_SMBIOS_MODE_SYSINFO", "sysinfo" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainOsSmBiosMode"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

GType
gvir_config_domain_os_boot_device_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_OS_BOOT_DEVICE_FD, "GVIR_CONFIG_DOMAIN_OS_BOOT_DEVICE_FD", "fd" },
        { GVIR_CONFIG_DOMAIN_OS_BOOT_DEVICE_HD, "GVIR_CONFIG_DOMAIN_OS_BOOT_DEVICE_HD", "hd" },
        { GVIR_CONFIG_DOMAIN_OS_BOOT_DEVICE_CDROM, "GVIR_CONFIG_DOMAIN_OS_BOOT_DEVICE_CDROM", "cdrom" },
        { GVIR_CONFIG_DOMAIN_OS_BOOT_DEVICE_NETWORK, "GVIR_CONFIG_DOMAIN_OS_BOOT_DEVICE_NETWORK", "network" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainOsBootDevice"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain-redirdev.h" */
GType
gvir_config_domain_redirdev_bus_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_REDIRDEV_BUS_USB, "GVIR_CONFIG_DOMAIN_REDIRDEV_BUS_USB", "usb" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainRedirdevBus"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain-seclabel.h" */
GType
gvir_config_domain_seclabel_type_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_SECLABEL_DYNAMIC, "GVIR_CONFIG_DOMAIN_SECLABEL_DYNAMIC", "dynamic" },
        { GVIR_CONFIG_DOMAIN_SECLABEL_STATIC, "GVIR_CONFIG_DOMAIN_SECLABEL_STATIC", "static" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainSeclabelType"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain-snapshot.h" */
GType
gvir_config_domain_snapshot_domain_state_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_SNAPSHOT_DOMAIN_STATE_NOSTATE, "GVIR_CONFIG_DOMAIN_SNAPSHOT_DOMAIN_STATE_NOSTATE", "nostate" },
        { GVIR_CONFIG_DOMAIN_SNAPSHOT_DOMAIN_STATE_RUNNING, "GVIR_CONFIG_DOMAIN_SNAPSHOT_DOMAIN_STATE_RUNNING", "running" },
        { GVIR_CONFIG_DOMAIN_SNAPSHOT_DOMAIN_STATE_BLOCKED, "GVIR_CONFIG_DOMAIN_SNAPSHOT_DOMAIN_STATE_BLOCKED", "blocked" },
        { GVIR_CONFIG_DOMAIN_SNAPSHOT_DOMAIN_STATE_PAUSED, "GVIR_CONFIG_DOMAIN_SNAPSHOT_DOMAIN_STATE_PAUSED", "paused" },
        { GVIR_CONFIG_DOMAIN_SNAPSHOT_DOMAIN_STATE_SHUTDOWN, "GVIR_CONFIG_DOMAIN_SNAPSHOT_DOMAIN_STATE_SHUTDOWN", "shutdown" },
        { GVIR_CONFIG_DOMAIN_SNAPSHOT_DOMAIN_STATE_SHUTOFF, "GVIR_CONFIG_DOMAIN_SNAPSHOT_DOMAIN_STATE_SHUTOFF", "shutoff" },
        { GVIR_CONFIG_DOMAIN_SNAPSHOT_DOMAIN_STATE_CRASHED, "GVIR_CONFIG_DOMAIN_SNAPSHOT_DOMAIN_STATE_CRASHED", "crashed" },
        { GVIR_CONFIG_DOMAIN_SNAPSHOT_DOMAIN_STATE_PMSUSPENDED, "GVIR_CONFIG_DOMAIN_SNAPSHOT_DOMAIN_STATE_PMSUSPENDED", "pmsuspended" },
        { GVIR_CONFIG_DOMAIN_SNAPSHOT_DOMAIN_STATE_DISK_SNAPSHOT, "GVIR_CONFIG_DOMAIN_SNAPSHOT_DOMAIN_STATE_DISK_SNAPSHOT", "disk-snapshot" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainSnapshotDomainState"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

GType
gvir_config_domain_snapshot_memory_state_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_SNAPSHOT_MEMORY_STATE_NONE, "GVIR_CONFIG_DOMAIN_SNAPSHOT_MEMORY_STATE_NONE", "none" },
        { GVIR_CONFIG_DOMAIN_SNAPSHOT_MEMORY_STATE_INTERNAL, "GVIR_CONFIG_DOMAIN_SNAPSHOT_MEMORY_STATE_INTERNAL", "internal" },
        { GVIR_CONFIG_DOMAIN_SNAPSHOT_MEMORY_STATE_EXTERNAL, "GVIR_CONFIG_DOMAIN_SNAPSHOT_MEMORY_STATE_EXTERNAL", "external" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainSnapshotMemoryState"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain-sound.h" */
GType
gvir_config_domain_sound_model_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_SOUND_MODEL_SB16, "GVIR_CONFIG_DOMAIN_SOUND_MODEL_SB16", "sb16" },
        { GVIR_CONFIG_DOMAIN_SOUND_MODEL_ES1370, "GVIR_CONFIG_DOMAIN_SOUND_MODEL_ES1370", "es1370" },
        { GVIR_CONFIG_DOMAIN_SOUND_MODEL_PCSPK, "GVIR_CONFIG_DOMAIN_SOUND_MODEL_PCSPK", "pcspk" },
        { GVIR_CONFIG_DOMAIN_SOUND_MODEL_AC97, "GVIR_CONFIG_DOMAIN_SOUND_MODEL_AC97", "ac97" },
        { GVIR_CONFIG_DOMAIN_SOUND_MODEL_ICH6, "GVIR_CONFIG_DOMAIN_SOUND_MODEL_ICH6", "ich6" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainSoundModel"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain-timer.h" */
GType
gvir_config_domain_timer_tick_policy_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_TIMER_TICK_POLICY_DELAY, "GVIR_CONFIG_DOMAIN_TIMER_TICK_POLICY_DELAY", "delay" },
        { GVIR_CONFIG_DOMAIN_TIMER_TICK_POLICY_CATCHUP, "GVIR_CONFIG_DOMAIN_TIMER_TICK_POLICY_CATCHUP", "catchup" },
        { GVIR_CONFIG_DOMAIN_TIMER_TICK_POLICY_MERGE, "GVIR_CONFIG_DOMAIN_TIMER_TICK_POLICY_MERGE", "merge" },
        { GVIR_CONFIG_DOMAIN_TIMER_TICK_POLICY_DISCARD, "GVIR_CONFIG_DOMAIN_TIMER_TICK_POLICY_DISCARD", "discard" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainTimerTickPolicy"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-domain-video.h" */
GType
gvir_config_domain_video_model_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_DOMAIN_VIDEO_MODEL_VGA, "GVIR_CONFIG_DOMAIN_VIDEO_MODEL_VGA", "vga" },
        { GVIR_CONFIG_DOMAIN_VIDEO_MODEL_CIRRUS, "GVIR_CONFIG_DOMAIN_VIDEO_MODEL_CIRRUS", "cirrus" },
        { GVIR_CONFIG_DOMAIN_VIDEO_MODEL_VMVGA, "GVIR_CONFIG_DOMAIN_VIDEO_MODEL_VMVGA", "vmvga" },
        { GVIR_CONFIG_DOMAIN_VIDEO_MODEL_XEN, "GVIR_CONFIG_DOMAIN_VIDEO_MODEL_XEN", "xen" },
        { GVIR_CONFIG_DOMAIN_VIDEO_MODEL_VBOX, "GVIR_CONFIG_DOMAIN_VIDEO_MODEL_VBOX", "vbox" },
        { GVIR_CONFIG_DOMAIN_VIDEO_MODEL_QXL, "GVIR_CONFIG_DOMAIN_VIDEO_MODEL_QXL", "qxl" },
        { GVIR_CONFIG_DOMAIN_VIDEO_MODEL_VIRTIO, "GVIR_CONFIG_DOMAIN_VIDEO_MODEL_VIRTIO", "virtio" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigDomainVideoModel"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}

/* enumerations from "/usr/src/ports/libvirt-glib1.0/libvirt-glib1.0-1.0.0-1.i686/src/libvirt-glib-1.0.0/libvirt-gconfig/libvirt-gconfig-storage-pool.h" */
GType
gvir_config_storage_pool_type_get_type (void)
{
  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile))
    {
      static const GEnumValue values[] = {
        { GVIR_CONFIG_STORAGE_POOL_TYPE_DIR, "GVIR_CONFIG_STORAGE_POOL_TYPE_DIR", "dir" },
        { GVIR_CONFIG_STORAGE_POOL_TYPE_FS, "GVIR_CONFIG_STORAGE_POOL_TYPE_FS", "fs" },
        { GVIR_CONFIG_STORAGE_POOL_TYPE_NETFS, "GVIR_CONFIG_STORAGE_POOL_TYPE_NETFS", "netfs" },
        { GVIR_CONFIG_STORAGE_POOL_TYPE_LOGICAL, "GVIR_CONFIG_STORAGE_POOL_TYPE_LOGICAL", "logical" },
        { GVIR_CONFIG_STORAGE_POOL_TYPE_DISK, "GVIR_CONFIG_STORAGE_POOL_TYPE_DISK", "disk" },
        { GVIR_CONFIG_STORAGE_POOL_TYPE_ISCSI, "GVIR_CONFIG_STORAGE_POOL_TYPE_ISCSI", "iscsi" },
        { GVIR_CONFIG_STORAGE_POOL_TYPE_SCSI, "GVIR_CONFIG_STORAGE_POOL_TYPE_SCSI", "scsi" },
        { GVIR_CONFIG_STORAGE_POOL_TYPE_MPATH, "GVIR_CONFIG_STORAGE_POOL_TYPE_MPATH", "mpath" },
        { 0, NULL, NULL }
      };
      GType g_define_type_id =
        g_enum_register_static (g_intern_static_string ("GVirConfigStoragePoolType"), values);
      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
    }

  return g_define_type_id__volatile;
}


/* Generated data ends here */

