README 

==============
libvirt-go-xml
==============

.. image:: https://gitlab.com/libvirt/libvirt-go-xml/badges/master/pipeline.svg
   :target: https://gitlab.com/libvirt/libvirt-go-xml/pipelines
   :alt: Build Status
.. image:: https://img.shields.io/static/v1?label=godev&message=reference&color=00add8
   :target: https://pkg.go.dev/libvirt.org/libvirt-go-xml
   :alt: API Documentation

Go API for manipulating libvirt XML documents

This package provides a Go API that defines a set of structs, annotated for use
with "encoding/xml", that can represent libvirt XML documents. There is no
dependency on the libvirt library itself, so this can be used regardless of
the way in which the application talks to libvirt.


Documentation
=============

* `API documentation for the bindings <https://pkg.go.dev/libvirt.org/libvirt-go-xml>`_

* `Libvirt XML schema documentation <https://libvirt.org/format.html>`_

  * `capabilities <https://libvirt.org/formatcaps.html>`_
  * `domain <https://libvirt.org/formatdomain.html>`_
  * `domain capabilities <https://libvirt.org/formatdomaincaps.html>`_
  * `domain snapshot <https://libvirt.org/formatsnapshot.html>`_
  * `network <https://libvirt.org/formatnetwork.html>`_
  * `node device <https://libvirt.org/formatnode.html>`_
  * `nwfilter <https://libvirt.org/formatnwfilter.html>`_
  * `secret <https://libvirt.org/formatsecret.html>`_
  * `storage <https://libvirt.org/formatstorage.html>`_
  * `storage encryption <https://libvirt.org/formatstorageencryption.html>`_


Contributing
============

The libvirt project aims to add support for new XML elements to
libvirt-go-xml as soon as they are added to the main libvirt C
library. If you are submitting changes to the libvirt C library
that introduce new XML elements, please submit a libvirt-go-xml
change at the same time. Bug fixes and other improvements to the
libvirt-go-xml library are welcome at any time.

For more information, see the `CONTRIBUTING <CONTRIBUTING.rst>`_
file.
Expand ▾ Collapse ▴

Documentation

Overview

    Package libvirt-go-xml defines structs for parsing libvirt XML schemas

    The libvirt API uses XML schemas/documents to describe the configuration of many of its managed objects. Thus when using the libvirt-go package, it is often neccessary to either parse or format XML documents. This package defines a set of Go structs which have been annotated for use with the encoding/xml API to manage libvirt XML documents.

    Example creating a domain XML document from configuration: 

    package main

import (
 "libvirt.org/libvirt-go-xml"
)

func main() {
  domcfg := &libvirtxml.Domain{Type: "kvm", Name: "demo",
                               UUID: "8f99e332-06c4-463a-9099-330fb244e1b3",
                               ....}
  xmldoc, err := domcfg.Marshal()
}

    Example parsing a domainXML document, in combination with libvirt-go 

    package main

import (
  "libvirt.org/libvirt-go"
  "libvirt.org/libvirt-go-xml"
  "fmt"
)

func main() {
  conn, err := libvirt.NewConnect("qemu:///system")
  dom, err := conn.LookupDomainByName("demo")
  xmldoc, err := dom.GetXMLDesc(0)

  domcfg := &libvirtxml.Domain{}
  err = domcfg.Unmarshal(xmldoc)

  fmt.Printf("Virt type %s\n", domcfg.Type)
}

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type Caps 

    type Caps struct {
	XMLName xml.Name    `xml:"capabilities"`
	Host    CapsHost    `xml:"host"`
	Guests  []CapsGuest `xml:"guest"`
}

    func (*Caps) Marshal 

    func (c *Caps) Marshal() (string, error)

    func (*Caps) Unmarshal 

    func (c *Caps) Unmarshal(doc string) error

    type CapsGuest 

    type CapsGuest struct {
	OSType   string             `xml:"os_type"`
	Arch     CapsGuestArch      `xml:"arch"`
	Features *CapsGuestFeatures `xml:"features"`
}

    type CapsGuestArch 

    type CapsGuestArch struct {
	Name     string             `xml:"name,attr"`
	WordSize string             `xml:"wordsize"`
	Emulator string             `xml:"emulator"`
	Loader   string             `xml:"loader,omitempty"`
	Machines []CapsGuestMachine `xml:"machine"`
	Domains  []CapsGuestDomain  `xml:"domain"`
}

    type CapsGuestDomain 

    type CapsGuestDomain struct {
	Type     string             `xml:"type,attr"`
	Emulator string             `xml:"emulator,omitempty"`
	Machines []CapsGuestMachine `xml:"machine"`
}

    type CapsGuestFeatureACPI 

    type CapsGuestFeatureACPI struct {
	Default string `xml:"default,attr,omitempty"`
	Toggle  string `xml:"toggle,attr,omitempty"`
}

    type CapsGuestFeatureAPIC 

    type CapsGuestFeatureAPIC struct {
	Default string `xml:"default,attr,omitempty"`
	Toggle  string `xml:"toggle,attr,omitempty"`
}

    type CapsGuestFeatureCPUSelection 

    type CapsGuestFeatureCPUSelection struct {
}

    type CapsGuestFeatureDeviceBoot 

    type CapsGuestFeatureDeviceBoot struct {
}

    type CapsGuestFeatureDiskSnapshot 

    type CapsGuestFeatureDiskSnapshot struct {
	Default string `xml:"default,attr,omitempty"`
	Toggle  string `xml:"toggle,attr,omitempty"`
}

    type CapsGuestFeatureIA64BE 

    type CapsGuestFeatureIA64BE struct {
}

    type CapsGuestFeatureNonPAE 

    type CapsGuestFeatureNonPAE struct {
}

    type CapsGuestFeaturePAE 

    type CapsGuestFeaturePAE struct {
}

    type CapsGuestFeatures 

    type CapsGuestFeatures struct {
	CPUSelection *CapsGuestFeatureCPUSelection `xml:"cpuselection"`
	DeviceBoot   *CapsGuestFeatureDeviceBoot   `xml:"deviceboot"`
	DiskSnapshot *CapsGuestFeatureDiskSnapshot `xml:"disksnapshot"`
	PAE          *CapsGuestFeaturePAE          `xml:"pae"`
	NonPAE       *CapsGuestFeatureNonPAE       `xml:"nonpae"`
	APIC         *CapsGuestFeatureAPIC         `xml:"apic"`
	ACPI         *CapsGuestFeatureACPI         `xml:"acpi"`
	IA64BE       *CapsGuestFeatureIA64BE       `xml:"ia64_be"`
}

    type CapsGuestMachine 

    type CapsGuestMachine struct {
	Name      string `xml:",chardata"`
	MaxCPUs   int    `xml:"maxCpus,attr,omitempty"`
	Canonical string `xml:"canonical,attr,omitempty"`
}

    type CapsHost 

    type CapsHost struct {
	UUID              string                     `xml:"uuid,omitempty"`
	CPU               *CapsHostCPU               `xml:"cpu"`
	PowerManagement   *CapsHostPowerManagement   `xml:"power_management"`
	IOMMU             *CapsHostIOMMU             `xml:"iommu"`
	MigrationFeatures *CapsHostMigrationFeatures `xml:"migration_features"`
	NUMA              *CapsHostNUMATopology      `xml:"topology"`
	Cache             *CapsHostCache             `xml:"cache"`
	MemoryBandwidth   *CapsHostMemoryBandwidth   `xml:"memory_bandwidth"`
	SecModel          []CapsHostSecModel         `xml:"secmodel"`
}

    type CapsHostCPU 

    type CapsHostCPU struct {
	XMLName      xml.Name                 `xml:"cpu"`
	Arch         string                   `xml:"arch,omitempty"`
	Model        string                   `xml:"model,omitempty"`
	Vendor       string                   `xml:"vendor,omitempty"`
	Topology     *CapsHostCPUTopology     `xml:"topology"`
	FeatureFlags []CapsHostCPUFeatureFlag `xml:"feature"`
	Features     *CapsHostCPUFeatures     `xml:"features"`
	PageSizes    []CapsHostCPUPageSize    `xml:"pages"`
	Microcode    *CapsHostCPUMicrocode    `xml:"microcode"`
}

    func (*CapsHostCPU) Marshal 

    func (c *CapsHostCPU) Marshal() (string, error)

    func (*CapsHostCPU) Unmarshal 

    func (c *CapsHostCPU) Unmarshal(doc string) error

    type CapsHostCPUFeature 

    type CapsHostCPUFeature struct {
}

    type CapsHostCPUFeatureFlag 

    type CapsHostCPUFeatureFlag struct {
	Name string `xml:"name,attr"`
}

    type CapsHostCPUFeatures 

    type CapsHostCPUFeatures struct {
	PAE    *CapsHostCPUFeature `xml:"pae"`
	NonPAE *CapsHostCPUFeature `xml:"nonpae"`
	SVM    *CapsHostCPUFeature `xml:"svm"`
	VMX    *CapsHostCPUFeature `xml:"vmx"`
}

    type CapsHostCPUMicrocode 

    type CapsHostCPUMicrocode struct {
	Version int `xml:"version,attr"`
}

    type CapsHostCPUPageSize 

    type CapsHostCPUPageSize struct {
	Size int    `xml:"size,attr"`
	Unit string `xml:"unit,attr"`
}

    type CapsHostCPUTopology 

    type CapsHostCPUTopology struct {
	Sockets int `xml:"sockets,attr"`
	Cores   int `xml:"cores,attr"`
	Threads int `xml:"threads,attr"`
}

    type CapsHostCache 

    type CapsHostCache struct {
	Banks   []CapsHostCacheBank   `xml:"bank"`
	Monitor *CapsHostCacheMonitor `xml:"monitor"`
}

    type CapsHostCacheBank 

    type CapsHostCacheBank struct {
	ID      uint                   `xml:"id,attr"`
	Level   uint                   `xml:"level,attr"`
	Type    string                 `xml:"type,attr"`
	Size    uint                   `xml:"size,attr"`
	Unit    string                 `xml:"unit,attr"`
	CPUs    string                 `xml:"cpus,attr"`
	Control []CapsHostCacheControl `xml:"control"`
}

    type CapsHostCacheControl 

    type CapsHostCacheControl struct {
	Granularity uint   `xml:"granularity,attr"`
	Min         uint   `xml:"min,attr,omitempty"`
	Unit        string `xml:"unit,attr"`
	Type        string `xml:"type,attr"`
	MaxAllows   uint   `xml:"maxAllocs,attr"`
}

    type CapsHostCacheMonitor 

    type CapsHostCacheMonitor struct {
	Level          uint                          `xml:"level,attr,omitempty"`
	ResueThreshold uint                          `xml:"reuseThreshold,attr,omitempty"`
	MaxMonitors    uint                          `xml:"maxMonitors,attr"`
	Features       []CapsHostCacheMonitorFeature `xml:"feature"`
}

    type CapsHostCacheMonitorFeature 

    type CapsHostCacheMonitorFeature struct {
	Name string `xml:"name,attr"`
}

    type CapsHostIOMMU 

    type CapsHostIOMMU struct {
	Support string `xml:"support,attr"`
}

    type CapsHostMemoryBandwidth 

    type CapsHostMemoryBandwidth struct {
	Nodes   []CapsHostMemoryBandwidthNode   `xml:"node"`
	Monitor *CapsHostMemoryBandwidthMonitor `xml:"monitor"`
}

    type CapsHostMemoryBandwidthMonitor 

    type CapsHostMemoryBandwidthMonitor struct {
	MaxMonitors uint                                    `xml:"maxMonitors,attr"`
	Features    []CapsHostMemoryBandwidthMonitorFeature `xml:"feature"`
}

    type CapsHostMemoryBandwidthMonitorFeature 

    type CapsHostMemoryBandwidthMonitorFeature struct {
	Name string `xml:"name,attr"`
}

    type CapsHostMemoryBandwidthNode 

    type CapsHostMemoryBandwidthNode struct {
	ID      uint                                `xml:"id,attr"`
	CPUs    string                              `xml:"cpus,attr"`
	Control *CapsHostMemoryBandwidthNodeControl `xml:"control"`
}

    type CapsHostMemoryBandwidthNodeControl 

    type CapsHostMemoryBandwidthNodeControl struct {
	Granularity uint `xml:"granularity,attr"`
	Min         uint `xml:"min,attr"`
	MaxAllocs   uint `xml:"maxAllocs,attr"`
}

    type CapsHostMigrationFeatures 

    type CapsHostMigrationFeatures struct {
	Live          *CapsHostMigrationLive          `xml:"live"`
	URITransports *CapsHostMigrationURITransports `xml:"uri_transports"`
}

    type CapsHostMigrationLive 

    type CapsHostMigrationLive struct {
}

    type CapsHostMigrationURITransports 

    type CapsHostMigrationURITransports struct {
	URI []string `xml:"uri_transport"`
}

    type CapsHostNUMACPU 

    type CapsHostNUMACPU struct {
	ID       int    `xml:"id,attr"`
	SocketID *int   `xml:"socket_id,attr"`
	DieID    *int   `xml:"die_id,attr"`
	CoreID   *int   `xml:"core_id,attr"`
	Siblings string `xml:"siblings,attr,omitempty"`
}

    type CapsHostNUMACPUs 

    type CapsHostNUMACPUs struct {
	Num  uint              `xml:"num,attr,omitempty"`
	CPUs []CapsHostNUMACPU `xml:"cpu"`
}

    type CapsHostNUMACell 

    type CapsHostNUMACell struct {
	ID        int                    `xml:"id,attr"`
	Memory    *CapsHostNUMAMemory    `xml:"memory"`
	PageInfo  []CapsHostNUMAPageInfo `xml:"pages"`
	Distances *CapsHostNUMADistances `xml:"distances"`
	CPUS      *CapsHostNUMACPUs      `xml:"cpus"`
}

    type CapsHostNUMACells 

    type CapsHostNUMACells struct {
	Num   uint               `xml:"num,attr,omitempty"`
	Cells []CapsHostNUMACell `xml:"cell"`
}

    type CapsHostNUMADistances 

    type CapsHostNUMADistances struct {
	Siblings []CapsHostNUMASibling `xml:"sibling"`
}

    type CapsHostNUMAMemory 

    type CapsHostNUMAMemory struct {
	Size uint64 `xml:",chardata"`
	Unit string `xml:"unit,attr"`
}

    type CapsHostNUMAPageInfo 

    type CapsHostNUMAPageInfo struct {
	Size  int    `xml:"size,attr"`
	Unit  string `xml:"unit,attr"`
	Count uint64 `xml:",chardata"`
}

    type CapsHostNUMASibling 

    type CapsHostNUMASibling struct {
	ID    int `xml:"id,attr"`
	Value int `xml:"value,attr"`
}

    type CapsHostNUMATopology 

    type CapsHostNUMATopology struct {
	Cells *CapsHostNUMACells `xml:"cells"`
}

    type CapsHostPowerManagement 

    type CapsHostPowerManagement struct {
	SuspendMem    *CapsHostPowerManagementMode `xml:"suspend_mem"`
	SuspendDisk   *CapsHostPowerManagementMode `xml:"suspend_disk"`
	SuspendHybrid *CapsHostPowerManagementMode `xml:"suspend_hybrid"`
}

    type CapsHostPowerManagementMode 

    type CapsHostPowerManagementMode struct {
}

    type CapsHostSecModel 

    type CapsHostSecModel struct {
	Name   string                  `xml:"model"`
	DOI    string                  `xml:"doi"`
	Labels []CapsHostSecModelLabel `xml:"baselabel"`
}

    type CapsHostSecModelLabel 

    type CapsHostSecModelLabel struct {
	Type  string `xml:"type,attr"`
	Value string `xml:",chardata"`
}

    type Document 

    type Document interface {
	Unmarshal(doc string) error
	Marshal() (string, error)
}

    type Domain 

    type Domain struct {
	XMLName        xml.Name              `xml:"domain"`
	Type           string                `xml:"type,attr,omitempty"`
	ID             *int                  `xml:"id,attr"`
	Name           string                `xml:"name,omitempty"`
	UUID           string                `xml:"uuid,omitempty"`
	GenID          *DomainGenID          `xml:"genid"`
	Title          string                `xml:"title,omitempty"`
	Description    string                `xml:"description,omitempty"`
	Metadata       *DomainMetadata       `xml:"metadata"`
	MaximumMemory  *DomainMaxMemory      `xml:"maxMemory"`
	Memory         *DomainMemory         `xml:"memory"`
	CurrentMemory  *DomainCurrentMemory  `xml:"currentMemory"`
	BlockIOTune    *DomainBlockIOTune    `xml:"blkiotune"`
	MemoryTune     *DomainMemoryTune     `xml:"memtune"`
	MemoryBacking  *DomainMemoryBacking  `xml:"memoryBacking"`
	VCPU           *DomainVCPU           `xml:"vcpu"`
	VCPUs          *DomainVCPUs          `xml:"vcpus"`
	IOThreads      uint                  `xml:"iothreads,omitempty"`
	IOThreadIDs    *DomainIOThreadIDs    `xml:"iothreadids"`
	CPUTune        *DomainCPUTune        `xml:"cputune"`
	NUMATune       *DomainNUMATune       `xml:"numatune"`
	Resource       *DomainResource       `xml:"resource"`
	SysInfo        []DomainSysInfo       `xml:"sysinfo"`
	Bootloader     string                `xml:"bootloader,omitempty"`
	BootloaderArgs string                `xml:"bootloader_args,omitempty"`
	OS             *DomainOS             `xml:"os"`
	IDMap          *DomainIDMap          `xml:"idmap"`
	Features       *DomainFeatureList    `xml:"features"`
	CPU            *DomainCPU            `xml:"cpu"`
	Clock          *DomainClock          `xml:"clock"`
	OnPoweroff     string                `xml:"on_poweroff,omitempty"`
	OnReboot       string                `xml:"on_reboot,omitempty"`
	OnCrash        string                `xml:"on_crash,omitempty"`
	PM             *DomainPM             `xml:"pm"`
	Perf           *DomainPerf           `xml:"perf"`
	Devices        *DomainDeviceList     `xml:"devices"`
	SecLabel       []DomainSecLabel      `xml:"seclabel"`
	KeyWrap        *DomainKeyWrap        `xml:"keywrap"`
	LaunchSecurity *DomainLaunchSecurity `xml:"launchSecurity"`

	/* Hypervisor namespaces must all be last */
	QEMUCommandline      *DomainQEMUCommandline
	QEMUCapabilities     *DomainQEMUCapabilities
	LXCNamespace         *DomainLXCNamespace
	BHyveCommandline     *DomainBHyveCommandline
	VMWareDataCenterPath *DomainVMWareDataCenterPath
	XenCommandline       *DomainXenCommandline
}

      NB, try to keep the order of fields in this struct matching the order of XML elements that libvirt will generate when dumping XML.

      func (*Domain) Marshal 

      func (d *Domain) Marshal() (string, error)

      func (*Domain) Unmarshal 

      func (d *Domain) Unmarshal(doc string) error

      type DomainACPI 

      type DomainACPI struct {
	Tables []DomainACPITable `xml:"table"`
}

      type DomainACPITable 

      type DomainACPITable struct {
	Type string `xml:"type,attr"`
	Path string `xml:",chardata"`
}

      type DomainAddress 

      type DomainAddress struct {
	PCI          *DomainAddressPCI
	Drive        *DomainAddressDrive
	VirtioSerial *DomainAddressVirtioSerial
	CCID         *DomainAddressCCID
	USB          *DomainAddressUSB
	SpaprVIO     *DomainAddressSpaprVIO
	VirtioS390   *DomainAddressVirtioS390
	CCW          *DomainAddressCCW
	VirtioMMIO   *DomainAddressVirtioMMIO
	ISA          *DomainAddressISA
	DIMM         *DomainAddressDIMM
	Unassigned   *DomainAddressUnassigned
}

      func (*DomainAddress) MarshalXML 

      func (a *DomainAddress) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainAddress) UnmarshalXML 

      func (a *DomainAddress) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainAddressCCID 

      type DomainAddressCCID struct {
	Controller *uint `xml:"controller,attr"`
	Slot       *uint `xml:"slot,attr"`
}

      func (*DomainAddressCCID) MarshalXML 

      func (a *DomainAddressCCID) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainAddressCCID) UnmarshalXML 

      func (a *DomainAddressCCID) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainAddressCCW 

      type DomainAddressCCW struct {
	CSSID *uint `xml:"cssid,attr"`
	SSID  *uint `xml:"ssid,attr"`
	DevNo *uint `xml:"devno,attr"`
}

      func (*DomainAddressCCW) MarshalXML 

      func (a *DomainAddressCCW) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainAddressCCW) UnmarshalXML 

      func (a *DomainAddressCCW) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainAddressDIMM 

      type DomainAddressDIMM struct {
	Slot *uint   `xml:"slot,attr"`
	Base *uint64 `xml:"base,attr"`
}

      func (*DomainAddressDIMM) MarshalXML 

      func (a *DomainAddressDIMM) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainAddressDIMM) UnmarshalXML 

      func (a *DomainAddressDIMM) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainAddressDrive 

      type DomainAddressDrive struct {
	Controller *uint `xml:"controller,attr"`
	Bus        *uint `xml:"bus,attr"`
	Target     *uint `xml:"target,attr"`
	Unit       *uint `xml:"unit,attr"`
}

      func (*DomainAddressDrive) MarshalXML 

      func (a *DomainAddressDrive) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainAddressDrive) UnmarshalXML 

      func (a *DomainAddressDrive) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainAddressISA 

      type DomainAddressISA struct {
	IOBase *uint `xml:"iobase,attr"`
	IRQ    *uint `xml:"irq,attr"`
}

      func (*DomainAddressISA) MarshalXML 

      func (a *DomainAddressISA) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainAddressISA) UnmarshalXML 

      func (a *DomainAddressISA) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainAddressMDev 

      type DomainAddressMDev struct {
	UUID string `xml:"uuid,attr"`
}

      type DomainAddressPCI 

      type DomainAddressPCI struct {
	Domain        *uint              `xml:"domain,attr"`
	Bus           *uint              `xml:"bus,attr"`
	Slot          *uint              `xml:"slot,attr"`
	Function      *uint              `xml:"function,attr"`
	MultiFunction string             `xml:"multifunction,attr,omitempty"`
	ZPCI          *DomainAddressZPCI `xml:"zpci"`
}

      func (*DomainAddressPCI) MarshalXML 

      func (a *DomainAddressPCI) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainAddressPCI) UnmarshalXML 

      func (a *DomainAddressPCI) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainAddressSpaprVIO 

      type DomainAddressSpaprVIO struct {
	Reg *uint64 `xml:"reg,attr"`
}

      func (*DomainAddressSpaprVIO) MarshalXML 

      func (a *DomainAddressSpaprVIO) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainAddressSpaprVIO) UnmarshalXML 

      func (a *DomainAddressSpaprVIO) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainAddressUSB 

      type DomainAddressUSB struct {
	Bus    *uint  `xml:"bus,attr"`
	Port   string `xml:"port,attr,omitempty"`
	Device *uint  `xml:"device,attr"`
}

      func (*DomainAddressUSB) MarshalXML 

      func (a *DomainAddressUSB) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainAddressUSB) UnmarshalXML 

      func (a *DomainAddressUSB) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainAddressUnassigned 

      type DomainAddressUnassigned struct {
}

      func (*DomainAddressUnassigned) MarshalXML 

      func (a *DomainAddressUnassigned) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainAddressUnassigned) UnmarshalXML 

      func (a *DomainAddressUnassigned) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainAddressVirtioMMIO 

      type DomainAddressVirtioMMIO struct {
}

      func (*DomainAddressVirtioMMIO) MarshalXML 

      func (a *DomainAddressVirtioMMIO) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainAddressVirtioMMIO) UnmarshalXML 

      func (a *DomainAddressVirtioMMIO) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainAddressVirtioS390 

      type DomainAddressVirtioS390 struct {
}

      func (*DomainAddressVirtioS390) MarshalXML 

      func (a *DomainAddressVirtioS390) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainAddressVirtioS390) UnmarshalXML 

      func (a *DomainAddressVirtioS390) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainAddressVirtioSerial 

      type DomainAddressVirtioSerial struct {
	Controller *uint `xml:"controller,attr"`
	Bus        *uint `xml:"bus,attr"`
	Port       *uint `xml:"port,attr"`
}

      func (*DomainAddressVirtioSerial) MarshalXML 

      func (a *DomainAddressVirtioSerial) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainAddressVirtioSerial) UnmarshalXML 

      func (a *DomainAddressVirtioSerial) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainAddressZPCI 

      type DomainAddressZPCI struct {
	UID *uint `xml:"uid,attr,omitempty"`
	FID *uint `xml:"fid,attr,omitempty"`
}

      func (*DomainAddressZPCI) MarshalXML 

      func (a *DomainAddressZPCI) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainAddressZPCI) UnmarshalXML 

      func (a *DomainAddressZPCI) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainAlias 

      type DomainAlias struct {
	Name string `xml:"name,attr"`
}

      type DomainAudio 

      type DomainAudio struct {
	XMLName xml.Name        `xml:"audio"`
	OSS     *DomainAudioOSS `xml:"-"`
}

      func (*DomainAudio) MarshalXML 

      func (a *DomainAudio) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainAudio) UnmarshalXML 

      func (a *DomainAudio) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainAudioOSS 

      type DomainAudioOSS struct {
	ID     int                    `xml:"id,attr"`
	Input  *DomainAudioOSSChannel `xml:"input"`
	Output *DomainAudioOSSChannel `xml:"output"`
}

      type DomainAudioOSSChannel 

      type DomainAudioOSSChannel struct {
	Dev string `xml:"dev,attr"`
}

      type DomainBHyveCommandline 

      type DomainBHyveCommandline struct {
	XMLName xml.Name                    `xml:"http://libvirt.org/schemas/domain/bhyve/1.0 commandline"`
	Args    []DomainBHyveCommandlineArg `xml:"arg"`
	Envs    []DomainBHyveCommandlineEnv `xml:"env"`
}

      type DomainBHyveCommandlineArg 

      type DomainBHyveCommandlineArg struct {
	Value string `xml:"value,attr"`
}

      type DomainBHyveCommandlineEnv 

      type DomainBHyveCommandlineEnv struct {
	Name  string `xml:"name,attr"`
	Value string `xml:"value,attr,omitempty"`
}

      type DomainBIOS 

      type DomainBIOS struct {
	UseSerial     string `xml:"useserial,attr,omitempty"`
	RebootTimeout *int   `xml:"rebootTimeout,attr"`
}

      type DomainBackendDomain 

      type DomainBackendDomain struct {
	Name string `xml:"name,attr"`
}

      type DomainBlockIOTune 

      type DomainBlockIOTune struct {
	Weight uint                      `xml:"weight,omitempty"`
	Device []DomainBlockIOTuneDevice `xml:"device"`
}

      type DomainBlockIOTuneDevice 

      type DomainBlockIOTuneDevice struct {
	Path          string `xml:"path"`
	Weight        uint   `xml:"weight,omitempty"`
	ReadIopsSec   uint   `xml:"read_iops_sec,omitempty"`
	WriteIopsSec  uint   `xml:"write_iops_sec,omitempty"`
	ReadBytesSec  uint   `xml:"read_bytes_sec,omitempty"`
	WriteBytesSec uint   `xml:"write_bytes_sec,omitempty"`
}

      type DomainBootDevice 

      type DomainBootDevice struct {
	Dev string `xml:"dev,attr"`
}

      type DomainBootMenu 

      type DomainBootMenu struct {
	Enable  string `xml:"enable,attr,omitempty"`
	Timeout string `xml:"timeout,attr,omitempty"`
}

      type DomainCPU 

      type DomainCPU struct {
	XMLName    xml.Name           `xml:"cpu"`
	Match      string             `xml:"match,attr,omitempty"`
	Mode       string             `xml:"mode,attr,omitempty"`
	Check      string             `xml:"check,attr,omitempty"`
	Migratable string             `xml:"migratable,attr,omitempty"`
	Model      *DomainCPUModel    `xml:"model"`
	Vendor     string             `xml:"vendor,omitempty"`
	Topology   *DomainCPUTopology `xml:"topology"`
	Cache      *DomainCPUCache    `xml:"cache"`
	Features   []DomainCPUFeature `xml:"feature"`
	Numa       *DomainNuma        `xml:"numa"`
}

      func (*DomainCPU) Marshal 

      func (d *DomainCPU) Marshal() (string, error)

      func (*DomainCPU) Unmarshal 

      func (d *DomainCPU) Unmarshal(doc string) error

      type DomainCPUCache 

      type DomainCPUCache struct {
	Level uint   `xml:"level,attr,omitempty"`
	Mode  string `xml:"mode,attr"`
}

      type DomainCPUCacheTune 

      type DomainCPUCacheTune struct {
	VCPUs   string                      `xml:"vcpus,attr,omitempty"`
	Cache   []DomainCPUCacheTuneCache   `xml:"cache"`
	Monitor []DomainCPUCacheTuneMonitor `xml:"monitor"`
}

      type DomainCPUCacheTuneCache 

      type DomainCPUCacheTuneCache struct {
	ID    uint   `xml:"id,attr"`
	Level uint   `xml:"level,attr"`
	Type  string `xml:"type,attr"`
	Size  uint   `xml:"size,attr"`
	Unit  string `xml:"unit,attr"`
}

      type DomainCPUCacheTuneMonitor 

      type DomainCPUCacheTuneMonitor struct {
	Level uint   `xml:"level,attr,omitempty"`
	VCPUs string `xml:"vcpus,attr,omitempty"`
}

      type DomainCPUFeature 

      type DomainCPUFeature struct {
	Policy string `xml:"policy,attr,omitempty"`
	Name   string `xml:"name,attr,omitempty"`
}

      type DomainCPUMemoryTune 

      type DomainCPUMemoryTune struct {
	VCPUs   string                       `xml:"vcpus,attr"`
	Nodes   []DomainCPUMemoryTuneNode    `xml:"node"`
	Monitor []DomainCPUMemoryTuneMonitor `xml:"monitor"`
}

      type DomainCPUMemoryTuneMonitor 

      type DomainCPUMemoryTuneMonitor struct {
	Level uint   `xml:"level,attr,omitempty"`
	VCPUs string `xml:"vcpus,attr,omitempty"`
}

      type DomainCPUMemoryTuneNode 

      type DomainCPUMemoryTuneNode struct {
	ID        uint `xml:"id,attr"`
	Bandwidth uint `xml:"bandwidth,attr"`
}

      type DomainCPUModel 

      type DomainCPUModel struct {
	Fallback string `xml:"fallback,attr,omitempty"`
	Value    string `xml:",chardata"`
	VendorID string `xml:"vendor_id,attr,omitempty"`
}

      type DomainCPUTopology 

      type DomainCPUTopology struct {
	Sockets int `xml:"sockets,attr,omitempty"`
	Dies    int `xml:"dies,attr,omitempty"`
	Cores   int `xml:"cores,attr,omitempty"`
	Threads int `xml:"threads,attr,omitempty"`
}

      type DomainCPUTune 

      type DomainCPUTune struct {
	Shares         *DomainCPUTuneShares         `xml:"shares"`
	Period         *DomainCPUTunePeriod         `xml:"period"`
	Quota          *DomainCPUTuneQuota          `xml:"quota"`
	GlobalPeriod   *DomainCPUTunePeriod         `xml:"global_period"`
	GlobalQuota    *DomainCPUTuneQuota          `xml:"global_quota"`
	EmulatorPeriod *DomainCPUTunePeriod         `xml:"emulator_period"`
	EmulatorQuota  *DomainCPUTuneQuota          `xml:"emulator_quota"`
	IOThreadPeriod *DomainCPUTunePeriod         `xml:"iothread_period"`
	IOThreadQuota  *DomainCPUTuneQuota          `xml:"iothread_quota"`
	VCPUPin        []DomainCPUTuneVCPUPin       `xml:"vcpupin"`
	EmulatorPin    *DomainCPUTuneEmulatorPin    `xml:"emulatorpin"`
	IOThreadPin    []DomainCPUTuneIOThreadPin   `xml:"iothreadpin"`
	VCPUSched      []DomainCPUTuneVCPUSched     `xml:"vcpusched"`
	EmulatorSched  *DomainCPUTuneEmulatorSched  `xml:"emulatorsched"`
	IOThreadSched  []DomainCPUTuneIOThreadSched `xml:"iothreadsched"`
	CacheTune      []DomainCPUCacheTune         `xml:"cachetune"`
	MemoryTune     []DomainCPUMemoryTune        `xml:"memorytune"`
}

      type DomainCPUTuneEmulatorPin 

      type DomainCPUTuneEmulatorPin struct {
	CPUSet string `xml:"cpuset,attr"`
}

      type DomainCPUTuneEmulatorSched 

      type DomainCPUTuneEmulatorSched struct {
	Scheduler string `xml:"scheduler,attr,omitempty"`
	Priority  *int   `xml:"priority,attr"`
}

      type DomainCPUTuneIOThreadPin 

      type DomainCPUTuneIOThreadPin struct {
	IOThread uint   `xml:"iothread,attr"`
	CPUSet   string `xml:"cpuset,attr"`
}

      type DomainCPUTuneIOThreadSched 

      type DomainCPUTuneIOThreadSched struct {
	IOThreads string `xml:"iothreads,attr"`
	Scheduler string `xml:"scheduler,attr,omitempty"`
	Priority  *int   `xml:"priority,attr"`
}

      type DomainCPUTunePeriod 

      type DomainCPUTunePeriod struct {
	Value uint64 `xml:",chardata"`
}

      type DomainCPUTuneQuota 

      type DomainCPUTuneQuota struct {
	Value int64 `xml:",chardata"`
}

      type DomainCPUTuneShares 

      type DomainCPUTuneShares struct {
	Value uint `xml:",chardata"`
}

      type DomainCPUTuneVCPUPin 

      type DomainCPUTuneVCPUPin struct {
	VCPU   uint   `xml:"vcpu,attr"`
	CPUSet string `xml:"cpuset,attr"`
}

      type DomainCPUTuneVCPUSched 

      type DomainCPUTuneVCPUSched struct {
	VCPUs     string `xml:"vcpus,attr"`
	Scheduler string `xml:"scheduler,attr,omitempty"`
	Priority  *int   `xml:"priority,attr"`
}

      type DomainCaps 

      type DomainCaps struct {
	XMLName   xml.Name             `xml:"domainCapabilities"`
	Path      string               `xml:"path"`
	Domain    string               `xml:"domain"`
	Machine   string               `xml:"machine,omitempty"`
	Arch      string               `xml:"arch"`
	VCPU      *DomainCapsVCPU      `xml:"vcpu"`
	IOThreads *DomainCapsIOThreads `xml:"iothreads"`
	OS        *DomainCapsOS        `xml:"os"`
	CPU       *DomainCapsCPU       `xml:"cpu"`
	Devices   *DomainCapsDevices   `xml:"devices"`
	Features  *DomainCapsFeatures  `xml:"features"`
}

      func (*DomainCaps) Marshal 

      func (c *DomainCaps) Marshal() (string, error)

      func (*DomainCaps) Unmarshal 

      func (c *DomainCaps) Unmarshal(doc string) error

      type DomainCapsCPU 

      type DomainCapsCPU struct {
	Modes []DomainCapsCPUMode `xml:"mode"`
}

      type DomainCapsCPUFeature 

      type DomainCapsCPUFeature struct {
	Policy string `xml:"policy,attr,omitempty"`
	Name   string `xml:"name,attr"`
}

      type DomainCapsCPUMode 

      type DomainCapsCPUMode struct {
	Name      string                 `xml:"name,attr"`
	Supported string                 `xml:"supported,attr"`
	Models    []DomainCapsCPUModel   `xml:"model"`
	Vendor    string                 `xml:"vendor,omitempty"`
	Features  []DomainCapsCPUFeature `xml:"feature"`
	Enums     []DomainCapsEnum       `xml:"enum"`
}

      type DomainCapsCPUModel 

      type DomainCapsCPUModel struct {
	Name       string `xml:",chardata"`
	Usable     string `xml:"usable,attr,omitempty"`
	Fallback   string `xml:"fallback,attr,omitempty"`
	Deprecated string `xml:"deprecated,attr,omitempty"`
}

      type DomainCapsDevice 

      type DomainCapsDevice struct {
	Supported string           `xml:"supported,attr"`
	Enums     []DomainCapsEnum `xml:"enum"`
}

      type DomainCapsDevices 

      type DomainCapsDevices struct {
	Disk     *DomainCapsDevice `xml:"disk"`
	Graphics *DomainCapsDevice `xml:"graphics"`
	Video    *DomainCapsDevice `xml:"video"`
	HostDev  *DomainCapsDevice `xml:"hostdev"`
	RNG      *DomainCapsDevice `xml:"rng"`
}

      type DomainCapsEnum 

      type DomainCapsEnum struct {
	Name   string   `xml:"name,attr"`
	Values []string `xml:"value"`
}

      type DomainCapsFeatureBackingStoreInput 

      type DomainCapsFeatureBackingStoreInput struct {
	Supported string `xml:"supported,attr"`
}

      type DomainCapsFeatureBackup 

      type DomainCapsFeatureBackup struct {
	Supported string `xml:"supported,attr"`
}

      type DomainCapsFeatureGIC 

      type DomainCapsFeatureGIC struct {
	Supported string           `xml:"supported,attr"`
	Enums     []DomainCapsEnum `xml:"enum"`
}

      type DomainCapsFeatureGenID 

      type DomainCapsFeatureGenID struct {
	Supported string `xml:"supported,attr"`
}

      type DomainCapsFeatureSEV 

      type DomainCapsFeatureSEV struct {
	Supported       string `xml:"supported,attr"`
	CBitPos         uint   `xml:"cbitpos,omitempty"`
	ReducedPhysBits uint   `xml:"reducedPhysBits,omitempty"`
}

      type DomainCapsFeatureVMCoreInfo 

      type DomainCapsFeatureVMCoreInfo struct {
	Supported string `xml:"supported,attr"`
}

      type DomainCapsFeatures 

      type DomainCapsFeatures struct {
	GIC               *DomainCapsFeatureGIC               `xml:"gic"`
	VMCoreInfo        *DomainCapsFeatureVMCoreInfo        `xml:"vmcoreinfo"`
	GenID             *DomainCapsFeatureGenID             `xml:"genid"`
	BackingStoreInput *DomainCapsFeatureBackingStoreInput `xml:"backingStoreInput"`
	Backup            *DomainCapsFeatureBackup            `xml:"backup"`
	SEV               *DomainCapsFeatureSEV               `xml:"sev"`
}

      type DomainCapsIOThreads 

      type DomainCapsIOThreads struct {
	Supported string `xml:"supported,attr"`
}

      type DomainCapsOS 

      type DomainCapsOS struct {
	Supported string              `xml:"supported,attr"`
	Loader    *DomainCapsOSLoader `xml:"loader"`
	Enums     []DomainCapsEnum    `xml:"enum"`
}

      type DomainCapsOSLoader 

      type DomainCapsOSLoader struct {
	Supported string           `xml:"supported,attr"`
	Values    []string         `xml:"value"`
	Enums     []DomainCapsEnum `xml:"enum"`
}

      type DomainCapsVCPU 

      type DomainCapsVCPU struct {
	Max uint `xml:"max,attr"`
}

      type DomainCell 

      type DomainCell struct {
	ID        *uint                `xml:"id,attr"`
	CPUs      string               `xml:"cpus,attr,omitempty"`
	Memory    uint                 `xml:"memory,attr"`
	Unit      string               `xml:"unit,attr,omitempty"`
	MemAccess string               `xml:"memAccess,attr,omitempty"`
	Discard   string               `xml:"discard,attr,omitempty"`
	Distances *DomainCellDistances `xml:"distances"`
	Caches    []DomainCellCache    `xml:"cache"`
}

      type DomainCellCache 

      type DomainCellCache struct {
	Level         uint                `xml:"level,attr"`
	Associativity string              `xml:"associativity,attr"`
	Policy        string              `xml:"policy,attr"`
	Size          DomainCellCacheSize `xml:"size"`
	Line          DomainCellCacheLine `xml:"line"`
}

      type DomainCellCacheLine 

      type DomainCellCacheLine struct {
	Value string `xml:"value,attr"`
	Unit  string `xml:"unit,attr"`
}

      type DomainCellCacheSize 

      type DomainCellCacheSize struct {
	Value string `xml:"value,attr"`
	Unit  string `xml:"unit,attr"`
}

      type DomainCellDistances 

      type DomainCellDistances struct {
	Siblings []DomainCellSibling `xml:"sibling"`
}

      type DomainCellSibling 

      type DomainCellSibling struct {
	ID    uint `xml:"id,attr"`
	Value uint `xml:"value,attr"`
}

      type DomainChannel 

      type DomainChannel struct {
	XMLName  xml.Name               `xml:"channel"`
	Source   *DomainChardevSource   `xml:"source"`
	Protocol *DomainChardevProtocol `xml:"protocol"`
	Target   *DomainChannelTarget   `xml:"target"`
	Log      *DomainChardevLog      `xml:"log"`
	Alias    *DomainAlias           `xml:"alias"`
	Address  *DomainAddress         `xml:"address"`
}

      func (*DomainChannel) Marshal 

      func (d *DomainChannel) Marshal() (string, error)

      func (*DomainChannel) MarshalXML 

      func (a *DomainChannel) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainChannel) Unmarshal 

      func (d *DomainChannel) Unmarshal(doc string) error

      func (*DomainChannel) UnmarshalXML 

      func (a *DomainChannel) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainChannelTarget 

      type DomainChannelTarget struct {
	VirtIO   *DomainChannelTargetVirtIO   `xml:"-"`
	Xen      *DomainChannelTargetXen      `xml:"-"`
	GuestFWD *DomainChannelTargetGuestFWD `xml:"-"`
}

      func (*DomainChannelTarget) MarshalXML 

      func (a *DomainChannelTarget) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainChannelTarget) UnmarshalXML 

      func (a *DomainChannelTarget) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainChannelTargetGuestFWD 

      type DomainChannelTargetGuestFWD struct {
	Address string `xml:"address,attr,omitempty"`
	Port    string `xml:"port,attr,omitempty"`
}

      type DomainChannelTargetVirtIO 

      type DomainChannelTargetVirtIO struct {
	Name  string `xml:"name,attr,omitempty"`
	State string `xml:"state,attr,omitempty"` // is guest agent connected?
}

      type DomainChannelTargetXen 

      type DomainChannelTargetXen struct {
	Name  string `xml:"name,attr,omitempty"`
	State string `xml:"state,attr,omitempty"` // is guest agent connected?
}

      type DomainChardevLog 

      type DomainChardevLog struct {
	File   string `xml:"file,attr"`
	Append string `xml:"append,attr,omitempty"`
}

      type DomainChardevProtocol 

      type DomainChardevProtocol struct {
	Type string `xml:"type,attr"`
}

      type DomainChardevSource 

      type DomainChardevSource struct {
	Null      *DomainChardevSourceNull      `xml:"-"`
	VC        *DomainChardevSourceVC        `xml:"-"`
	Pty       *DomainChardevSourcePty       `xml:"-"`
	Dev       *DomainChardevSourceDev       `xml:"-"`
	File      *DomainChardevSourceFile      `xml:"-"`
	Pipe      *DomainChardevSourcePipe      `xml:"-"`
	StdIO     *DomainChardevSourceStdIO     `xml:"-"`
	UDP       *DomainChardevSourceUDP       `xml:"-"`
	TCP       *DomainChardevSourceTCP       `xml:"-"`
	UNIX      *DomainChardevSourceUNIX      `xml:"-"`
	SpiceVMC  *DomainChardevSourceSpiceVMC  `xml:"-"`
	SpicePort *DomainChardevSourceSpicePort `xml:"-"`
	NMDM      *DomainChardevSourceNMDM      `xml:"-"`
}

      func (*DomainChardevSource) MarshalXML 

      func (a *DomainChardevSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainChardevSource) UnmarshalXML 

      func (a *DomainChardevSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainChardevSourceDev 

      type DomainChardevSourceDev struct {
	Path     string                 `xml:"path,attr"`
	SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

      type DomainChardevSourceFile 

      type DomainChardevSourceFile struct {
	Path     string                 `xml:"path,attr"`
	Append   string                 `xml:"append,attr,omitempty"`
	SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

      type DomainChardevSourceNMDM 

      type DomainChardevSourceNMDM struct {
	Master string `xml:"master,attr"`
	Slave  string `xml:"slave,attr"`
}

      type DomainChardevSourceNull 

      type DomainChardevSourceNull struct {
}

      type DomainChardevSourcePipe 

      type DomainChardevSourcePipe struct {
	Path     string                 `xml:"path,attr"`
	SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

      type DomainChardevSourcePty 

      type DomainChardevSourcePty struct {
	Path     string                 `xml:"path,attr"`
	SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

      type DomainChardevSourceReconnect 

      type DomainChardevSourceReconnect struct {
	Enabled string `xml:"enabled,attr"`
	Timeout *uint  `xml:"timeout,attr"`
}

      type DomainChardevSourceSpicePort 

      type DomainChardevSourceSpicePort struct {
	Channel string `xml:"channel,attr"`
}

      type DomainChardevSourceSpiceVMC 

      type DomainChardevSourceSpiceVMC struct {
}

      type DomainChardevSourceStdIO 

      type DomainChardevSourceStdIO struct {
}

      type DomainChardevSourceTCP 

      type DomainChardevSourceTCP struct {
	Mode      string                        `xml:"mode,attr,omitempty"`
	Host      string                        `xml:"host,attr,omitempty"`
	Service   string                        `xml:"service,attr,omitempty"`
	TLS       string                        `xml:"tls,attr,omitempty"`
	Reconnect *DomainChardevSourceReconnect `xml:"reconnect"`
}

      type DomainChardevSourceUDP 

      type DomainChardevSourceUDP struct {
	BindHost       string `xml:"-"`
	BindService    string `xml:"-"`
	ConnectHost    string `xml:"-"`
	ConnectService string `xml:"-"`
}

      type DomainChardevSourceUNIX 

      type DomainChardevSourceUNIX struct {
	Mode      string                        `xml:"mode,attr,omitempty"`
	Path      string                        `xml:"path,attr,omitempty"`
	Reconnect *DomainChardevSourceReconnect `xml:"reconnect"`
	SecLabel  []DomainDeviceSecLabel        `xml:"seclabel"`
}

      type DomainChardevSourceVC 

      type DomainChardevSourceVC struct {
}

      type DomainChardevTarget 

      type DomainChardevTarget struct {
	Type  string `xml:"type,attr,omitempty"`
	Name  string `xml:"name,attr,omitempty"`
	State string `xml:"state,attr,omitempty"` // is guest agent connected?
	Port  *uint  `xml:"port,attr"`
}

      type DomainClock 

      type DomainClock struct {
	Offset     string        `xml:"offset,attr,omitempty"`
	Basis      string        `xml:"basis,attr,omitempty"`
	Adjustment string        `xml:"adjustment,attr,omitempty"`
	TimeZone   string        `xml:"timezone,attr,omitempty"`
	Timer      []DomainTimer `xml:"timer"`
}

      type DomainConsole 

      type DomainConsole struct {
	XMLName  xml.Name               `xml:"console"`
	TTY      string                 `xml:"tty,attr,omitempty"`
	Source   *DomainChardevSource   `xml:"source"`
	Protocol *DomainChardevProtocol `xml:"protocol"`
	Target   *DomainConsoleTarget   `xml:"target"`
	Log      *DomainChardevLog      `xml:"log"`
	Alias    *DomainAlias           `xml:"alias"`
	Address  *DomainAddress         `xml:"address"`
}

      func (*DomainConsole) Marshal 

      func (d *DomainConsole) Marshal() (string, error)

      func (*DomainConsole) MarshalXML 

      func (a *DomainConsole) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainConsole) Unmarshal 

      func (d *DomainConsole) Unmarshal(doc string) error

      func (*DomainConsole) UnmarshalXML 

      func (a *DomainConsole) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainConsoleTarget 

      type DomainConsoleTarget struct {
	Type string `xml:"type,attr,omitempty"`
	Port *uint  `xml:"port,attr"`
}

      type DomainController 

      type DomainController struct {
	XMLName      xml.Name                      `xml:"controller"`
	Type         string                        `xml:"type,attr"`
	Index        *uint                         `xml:"index,attr"`
	Model        string                        `xml:"model,attr,omitempty"`
	Driver       *DomainControllerDriver       `xml:"driver"`
	PCI          *DomainControllerPCI          `xml:"-"`
	USB          *DomainControllerUSB          `xml:"-"`
	VirtIOSerial *DomainControllerVirtIOSerial `xml:"-"`
	XenBus       *DomainControllerXenBus       `xml:"-"`
	Alias        *DomainAlias                  `xml:"alias"`
	Address      *DomainAddress                `xml:"address"`
}

      func (*DomainController) Marshal 

      func (d *DomainController) Marshal() (string, error)

      func (*DomainController) MarshalXML 

      func (a *DomainController) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainController) Unmarshal 

      func (d *DomainController) Unmarshal(doc string) error

      func (*DomainController) UnmarshalXML 

      func (a *DomainController) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainControllerDriver 

      type DomainControllerDriver struct {
	Queues     *uint  `xml:"queues,attr"`
	CmdPerLUN  *uint  `xml:"cmd_per_lun,attr"`
	MaxSectors *uint  `xml:"max_sectors,attr"`
	IOEventFD  string `xml:"ioeventfd,attr,omitempty"`
	IOThread   uint   `xml:"iothread,attr,omitempty"`
	IOMMU      string `xml:"iommu,attr,omitempty"`
	ATS        string `xml:"ats,attr,omitempty"`
	Packed     string `xml:"packed,attr,omitempty"`
}

      type DomainControllerPCI 

      type DomainControllerPCI struct {
	Model  *DomainControllerPCIModel  `xml:"model"`
	Target *DomainControllerPCITarget `xml:"target"`
	Hole64 *DomainControllerPCIHole64 `xml:"pcihole64"`
}

      type DomainControllerPCIHole64 

      type DomainControllerPCIHole64 struct {
	Size uint64 `xml:",chardata"`
	Unit string `xml:"unit,attr,omitempty"`
}

      type DomainControllerPCIModel 

      type DomainControllerPCIModel struct {
	Name string `xml:"name,attr"`
}

      type DomainControllerPCITarget 

      type DomainControllerPCITarget struct {
	ChassisNr *uint
	Chassis   *uint
	Port      *uint
	BusNr     *uint
	Index     *uint
	NUMANode  *uint
	Hotplug   string
}

      func (*DomainControllerPCITarget) MarshalXML 

      func (a *DomainControllerPCITarget) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainControllerPCITarget) UnmarshalXML 

      func (a *DomainControllerPCITarget) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainControllerUSB 

      type DomainControllerUSB struct {
	Port   *uint                      `xml:"ports,attr"`
	Master *DomainControllerUSBMaster `xml:"master"`
}

      type DomainControllerUSBMaster 

      type DomainControllerUSBMaster struct {
	StartPort uint `xml:"startport,attr"`
}

      type DomainControllerVirtIOSerial 

      type DomainControllerVirtIOSerial struct {
	Ports   *uint `xml:"ports,attr"`
	Vectors *uint `xml:"vectors,attr"`
}

      type DomainControllerXenBus 

      type DomainControllerXenBus struct {
	MaxGrantFrames   uint `xml:"maxGrantFrames,attr,omitempty"`
	MaxEventChannels uint `xml:"maxEventChannels,attr,omitempty"`
}

      type DomainCurrentMemory 

      type DomainCurrentMemory struct {
	Value uint   `xml:",chardata"`
	Unit  string `xml:"unit,attr,omitempty"`
}

      type DomainDeviceBoot 

      type DomainDeviceBoot struct {
	Order    uint   `xml:"order,attr"`
	LoadParm string `xml:"loadparm,attr,omitempty"`
}

      type DomainDeviceList 

      type DomainDeviceList struct {
	Emulator     string              `xml:"emulator,omitempty"`
	Disks        []DomainDisk        `xml:"disk"`
	Controllers  []DomainController  `xml:"controller"`
	Leases       []DomainLease       `xml:"lease"`
	Filesystems  []DomainFilesystem  `xml:"filesystem"`
	Interfaces   []DomainInterface   `xml:"interface"`
	Smartcards   []DomainSmartcard   `xml:"smartcard"`
	Serials      []DomainSerial      `xml:"serial"`
	Parallels    []DomainParallel    `xml:"parallel"`
	Consoles     []DomainConsole     `xml:"console"`
	Channels     []DomainChannel     `xml:"channel"`
	Inputs       []DomainInput       `xml:"input"`
	TPMs         []DomainTPM         `xml:"tpm"`
	Graphics     []DomainGraphic     `xml:"graphics"`
	Sounds       []DomainSound       `xml:"sound"`
	Audios       []DomainAudio       `xml:"audio"`
	Videos       []DomainVideo       `xml:"video"`
	Hostdevs     []DomainHostdev     `xml:"hostdev"`
	RedirDevs    []DomainRedirDev    `xml:"redirdev"`
	RedirFilters []DomainRedirFilter `xml:"redirfilter"`
	Hubs         []DomainHub         `xml:"hub"`
	Watchdog     *DomainWatchdog     `xml:"watchdog"`
	MemBalloon   *DomainMemBalloon   `xml:"memballoon"`
	RNGs         []DomainRNG         `xml:"rng"`
	NVRAM        *DomainNVRAM        `xml:"nvram"`
	Panics       []DomainPanic       `xml:"panic"`
	Shmems       []DomainShmem       `xml:"shmem"`
	Memorydevs   []DomainMemorydev   `xml:"memory"`
	IOMMU        *DomainIOMMU        `xml:"iommu"`
	VSock        *DomainVSock        `xml:"vsock"`
}

      type DomainDeviceSecLabel 

      type DomainDeviceSecLabel struct {
	Model     string `xml:"model,attr,omitempty"`
	LabelSkip string `xml:"labelskip,attr,omitempty"`
	Relabel   string `xml:"relabel,attr,omitempty"`
	Label     string `xml:"label,omitempty"`
}

      type DomainDisk 

      type DomainDisk struct {
	XMLName       xml.Name                `xml:"disk"`
	Device        string                  `xml:"device,attr,omitempty"`
	RawIO         string                  `xml:"rawio,attr,omitempty"`
	SGIO          string                  `xml:"sgio,attr,omitempty"`
	Snapshot      string                  `xml:"snapshot,attr,omitempty"`
	Model         string                  `xml:"model,attr,omitempty"`
	Driver        *DomainDiskDriver       `xml:"driver"`
	Auth          *DomainDiskAuth         `xml:"auth"`
	Source        *DomainDiskSource       `xml:"source"`
	BackingStore  *DomainDiskBackingStore `xml:"backingStore"`
	BackendDomain *DomainBackendDomain    `xml:"backenddomain"`
	Geometry      *DomainDiskGeometry     `xml:"geometry"`
	BlockIO       *DomainDiskBlockIO      `xml:"blockio"`
	Mirror        *DomainDiskMirror       `xml:"mirror"`
	Target        *DomainDiskTarget       `xml:"target"`
	IOTune        *DomainDiskIOTune       `xml:"iotune"`
	ReadOnly      *DomainDiskReadOnly     `xml:"readonly"`
	Shareable     *DomainDiskShareable    `xml:"shareable"`
	Transient     *DomainDiskTransient    `xml:"transient"`
	Serial        string                  `xml:"serial,omitempty"`
	WWN           string                  `xml:"wwn,omitempty"`
	Vendor        string                  `xml:"vendor,omitempty"`
	Product       string                  `xml:"product,omitempty"`
	Encryption    *DomainDiskEncryption   `xml:"encryption"`
	Boot          *DomainDeviceBoot       `xml:"boot"`
	Alias         *DomainAlias            `xml:"alias"`
	Address       *DomainAddress          `xml:"address"`
}

      func (*DomainDisk) Marshal 

      func (d *DomainDisk) Marshal() (string, error)

      func (*DomainDisk) MarshalXML 

      func (a *DomainDisk) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainDisk) Unmarshal 

      func (d *DomainDisk) Unmarshal(doc string) error

      func (*DomainDisk) UnmarshalXML 

      func (a *DomainDisk) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainDiskAuth 

      type DomainDiskAuth struct {
	Username string            `xml:"username,attr,omitempty"`
	Secret   *DomainDiskSecret `xml:"secret"`
}

      type DomainDiskBackingStore 

      type DomainDiskBackingStore struct {
	Index        uint                    `xml:"index,attr,omitempty"`
	Format       *DomainDiskFormat       `xml:"format"`
	Source       *DomainDiskSource       `xml:"source"`
	BackingStore *DomainDiskBackingStore `xml:"backingStore"`
}

      func (*DomainDiskBackingStore) MarshalXML 

      func (a *DomainDiskBackingStore) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainDiskBackingStore) UnmarshalXML 

      func (a *DomainDiskBackingStore) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainDiskBlockIO 

      type DomainDiskBlockIO struct {
	LogicalBlockSize  uint `xml:"logical_block_size,attr,omitempty"`
	PhysicalBlockSize uint `xml:"physical_block_size,attr,omitempty"`
}

      type DomainDiskCookie 

      type DomainDiskCookie struct {
	Name  string `xml:"name,attr"`
	Value string `xml:",chardata"`
}

      type DomainDiskCookies 

      type DomainDiskCookies struct {
	Cookies []DomainDiskCookie `xml:"cookie"`
}

      type DomainDiskDriver 

      type DomainDiskDriver struct {
	Name          string                   `xml:"name,attr,omitempty"`
	Type          string                   `xml:"type,attr,omitempty"`
	Cache         string                   `xml:"cache,attr,omitempty"`
	ErrorPolicy   string                   `xml:"error_policy,attr,omitempty"`
	RErrorPolicy  string                   `xml:"rerror_policy,attr,omitempty"`
	IO            string                   `xml:"io,attr,omitempty"`
	IOEventFD     string                   `xml:"ioeventfd,attr,omitempty"`
	EventIDX      string                   `xml:"event_idx,attr,omitempty"`
	CopyOnRead    string                   `xml:"copy_on_read,attr,omitempty"`
	Discard       string                   `xml:"discard,attr,omitempty"`
	IOThread      *uint                    `xml:"iothread,attr"`
	DetectZeros   string                   `xml:"detect_zeroes,attr,omitempty"`
	Queues        *uint                    `xml:"queues,attr"`
	IOMMU         string                   `xml:"iommu,attr,omitempty"`
	ATS           string                   `xml:"ats,attr,omitempty"`
	Packed        string                   `xml:"packed,attr,omitempty"`
	MetadataCache *DomainDiskMetadataCache `xml:"metadata_cache"`
}

      type DomainDiskEncryption 

      type DomainDiskEncryption struct {
	Format string            `xml:"format,attr,omitempty"`
	Secret *DomainDiskSecret `xml:"secret"`
}

      type DomainDiskFormat 

      type DomainDiskFormat struct {
	Type          string                   `xml:"type,attr"`
	MetadataCache *DomainDiskMetadataCache `xml:"metadata_cache"`
}

      type DomainDiskGeometry 

      type DomainDiskGeometry struct {
	Cylinders uint   `xml:"cyls,attr"`
	Headers   uint   `xml:"heads,attr"`
	Sectors   uint   `xml:"secs,attr"`
	Trans     string `xml:"trans,attr,omitempty"`
}

      type DomainDiskIOTune 

      type DomainDiskIOTune struct {
	TotalBytesSec          uint64 `xml:"total_bytes_sec,omitempty"`
	ReadBytesSec           uint64 `xml:"read_bytes_sec,omitempty"`
	WriteBytesSec          uint64 `xml:"write_bytes_sec,omitempty"`
	TotalIopsSec           uint64 `xml:"total_iops_sec,omitempty"`
	ReadIopsSec            uint64 `xml:"read_iops_sec,omitempty"`
	WriteIopsSec           uint64 `xml:"write_iops_sec,omitempty"`
	TotalBytesSecMax       uint64 `xml:"total_bytes_sec_max,omitempty"`
	ReadBytesSecMax        uint64 `xml:"read_bytes_sec_max,omitempty"`
	WriteBytesSecMax       uint64 `xml:"write_bytes_sec_max,omitempty"`
	TotalIopsSecMax        uint64 `xml:"total_iops_sec_max,omitempty"`
	ReadIopsSecMax         uint64 `xml:"read_iops_sec_max,omitempty"`
	WriteIopsSecMax        uint64 `xml:"write_iops_sec_max,omitempty"`
	TotalBytesSecMaxLength uint64 `xml:"total_bytes_sec_max_length,omitempty"`
	ReadBytesSecMaxLength  uint64 `xml:"read_bytes_sec_max_length,omitempty"`
	WriteBytesSecMaxLength uint64 `xml:"write_bytes_sec_max_length,omitempty"`
	TotalIopsSecMaxLength  uint64 `xml:"total_iops_sec_max_length,omitempty"`
	ReadIopsSecMaxLength   uint64 `xml:"read_iops_sec_max_length,omitempty"`
	WriteIopsSecMaxLength  uint64 `xml:"write_iops_sec_max_length,omitempty"`
	SizeIopsSec            uint64 `xml:"size_iops_sec,omitempty"`
	GroupName              string `xml:"group_name,omitempty"`
}

      type DomainDiskMetadataCache 

      type DomainDiskMetadataCache struct {
	MaxSize *DomainDiskMetadataCacheSize `xml:"max_size"`
}

      type DomainDiskMetadataCacheSize 

      type DomainDiskMetadataCacheSize struct {
	Unit  string `xml:"unit,attr,omitempty"`
	Value int    `xml:",cdata"`
}

      type DomainDiskMirror 

      type DomainDiskMirror struct {
	Job          string                  `xml:"job,attr,omitempty"`
	Ready        string                  `xml:"ready,attr,omitempty"`
	Format       *DomainDiskFormat       `xml:"format"`
	Source       *DomainDiskSource       `xml:"source"`
	BackingStore *DomainDiskBackingStore `xml:"backingStore"`
}

      func (*DomainDiskMirror) MarshalXML 

      func (a *DomainDiskMirror) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainDiskMirror) UnmarshalXML 

      func (a *DomainDiskMirror) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainDiskReadOnly 

      type DomainDiskReadOnly struct {
}

      type DomainDiskReservations 

      type DomainDiskReservations struct {
	Enabled string                        `xml:"enabled,attr,omitempty"`
	Managed string                        `xml:"managed,attr,omitempty"`
	Source  *DomainDiskReservationsSource `xml:"source"`
}

      type DomainDiskReservationsSource 

      type DomainDiskReservationsSource DomainChardevSource

      func (*DomainDiskReservationsSource) MarshalXML 

      func (a *DomainDiskReservationsSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainDiskReservationsSource) UnmarshalXML 

      func (a *DomainDiskReservationsSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainDiskSecret 

      type DomainDiskSecret struct {
	Type  string `xml:"type,attr,omitempty"`
	Usage string `xml:"usage,attr,omitempty"`
	UUID  string `xml:"uuid,attr,omitempty"`
}

      type DomainDiskShareable 

      type DomainDiskShareable struct {
}

      type DomainDiskSlice 

      type DomainDiskSlice struct {
	Type   string `xml:"type,attr"`
	Offset uint   `xml:"offset,attr"`
	Size   uint   `xml:"size,attr"`
}

      type DomainDiskSlices 

      type DomainDiskSlices struct {
	Slices []DomainDiskSlice `xml:"slice"`
}

      type DomainDiskSource 

      type DomainDiskSource struct {
	File          *DomainDiskSourceFile      `xml:"-"`
	Block         *DomainDiskSourceBlock     `xml:"-"`
	Dir           *DomainDiskSourceDir       `xml:"-"`
	Network       *DomainDiskSourceNetwork   `xml:"-"`
	Volume        *DomainDiskSourceVolume    `xml:"-"`
	NVME          *DomainDiskSourceNVME      `xml:"-"`
	VHostUser     *DomainDiskSourceVHostUser `xml:"-"`
	StartupPolicy string                     `xml:"startupPolicy,attr,omitempty"`
	Index         uint                       `xml:"index,attr,omitempty"`
	Encryption    *DomainDiskEncryption      `xml:"encryption"`
	Reservations  *DomainDiskReservations    `xml:"reservations"`
	Slices        *DomainDiskSlices          `xml:"slices"`
	SSL           *DomainDiskSourceSSL       `xml:"ssl"`
	Cookies       *DomainDiskCookies         `xml:"cookies"`
	Readahead     *DomainDiskSourceReadahead `xml:"readahead"`
	Timeout       *DomainDiskSourceTimeout   `xml:"timeout"`
}

      func (*DomainDiskSource) MarshalXML 

      func (a *DomainDiskSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainDiskSource) UnmarshalXML 

      func (a *DomainDiskSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainDiskSourceBlock 

      type DomainDiskSourceBlock struct {
	Dev      string                 `xml:"dev,attr,omitempty"`
	SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

      type DomainDiskSourceDir 

      type DomainDiskSourceDir struct {
	Dir string `xml:"dir,attr,omitempty"`
}

      type DomainDiskSourceFile 

      type DomainDiskSourceFile struct {
	File     string                 `xml:"file,attr,omitempty"`
	SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

      type DomainDiskSourceHost 

      type DomainDiskSourceHost struct {
	Transport string `xml:"transport,attr,omitempty"`
	Name      string `xml:"name,attr,omitempty"`
	Port      string `xml:"port,attr,omitempty"`
	Socket    string `xml:"socket,attr,omitempty"`
}

      type DomainDiskSourceNVME 

      type DomainDiskSourceNVME struct {
	PCI *DomainDiskSourceNVMEPCI
}

      type DomainDiskSourceNVMEPCI 

      type DomainDiskSourceNVMEPCI struct {
	Managed   string            `xml:"managed,attr,omitempty"`
	Namespace uint64            `xml:"namespace,attr,omitempty"`
	Address   *DomainAddressPCI `xml:"address"`
}

      type DomainDiskSourceNetwork 

      type DomainDiskSourceNetwork struct {
	Protocol  string                            `xml:"protocol,attr,omitempty"`
	Name      string                            `xml:"name,attr,omitempty"`
	Query     string                            `xml:"query,attr,omitempty"`
	TLS       string                            `xml:"tls,attr,omitempty"`
	Hosts     []DomainDiskSourceHost            `xml:"host"`
	Identity  *DomainDiskSourceNetworkIdentity  `xml:"identity"`
	Initiator *DomainDiskSourceNetworkInitiator `xml:"initiator"`
	Snapshot  *DomainDiskSourceNetworkSnapshot  `xml:"snapshot"`
	Config    *DomainDiskSourceNetworkConfig    `xml:"config"`
	Auth      *DomainDiskAuth                   `xml:"auth"`
}

      type DomainDiskSourceNetworkConfig 

      type DomainDiskSourceNetworkConfig struct {
	File string `xml:"file,attr"`
}

      type DomainDiskSourceNetworkIQN 

      type DomainDiskSourceNetworkIQN struct {
	Name string `xml:"name,attr,omitempty"`
}

      type DomainDiskSourceNetworkIdentity 

      type DomainDiskSourceNetworkIdentity struct {
	User  string `xml:"user,attr"`
	Group string `xml:"group,attr"`
}

      type DomainDiskSourceNetworkInitiator 

      type DomainDiskSourceNetworkInitiator struct {
	IQN *DomainDiskSourceNetworkIQN `xml:"iqn"`
}

      type DomainDiskSourceNetworkSnapshot 

      type DomainDiskSourceNetworkSnapshot struct {
	Name string `xml:"name,attr"`
}

      type DomainDiskSourceReadahead 

      type DomainDiskSourceReadahead struct {
	Size string `xml:"size,attr"`
}

      type DomainDiskSourceSSL 

      type DomainDiskSourceSSL struct {
	Verify string `xml:"verify,attr"`
}

      type DomainDiskSourceTimeout 

      type DomainDiskSourceTimeout struct {
	Seconds string `xml:"seconds,attr"`
}

      type DomainDiskSourceVHostUser 

      type DomainDiskSourceVHostUser DomainChardevSource

      func (*DomainDiskSourceVHostUser) MarshalXML 

      func (a *DomainDiskSourceVHostUser) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainDiskSourceVHostUser) UnmarshalXML 

      func (a *DomainDiskSourceVHostUser) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainDiskSourceVolume 

      type DomainDiskSourceVolume struct {
	Pool     string                 `xml:"pool,attr,omitempty"`
	Volume   string                 `xml:"volume,attr,omitempty"`
	Mode     string                 `xml:"mode,attr,omitempty"`
	SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

      type DomainDiskTarget 

      type DomainDiskTarget struct {
	Dev       string `xml:"dev,attr,omitempty"`
	Bus       string `xml:"bus,attr,omitempty"`
	Tray      string `xml:"tray,attr,omitempty"`
	Removable string `xml:"removable,attr,omitempty"`
}

      type DomainDiskTransient 

      type DomainDiskTransient struct {
}

      type DomainFeature 

      type DomainFeature struct {
}

      type DomainFeatureAPIC 

      type DomainFeatureAPIC struct {
	EOI string `xml:"eoi,attr,omitempty"`
}

      type DomainFeatureCFPC 

      type DomainFeatureCFPC struct {
	Value string `xml:"value,attr"`
}

      type DomainFeatureCapabilities 

      type DomainFeatureCapabilities struct {
	Policy         string                   `xml:"policy,attr,omitempty"`
	AuditControl   *DomainFeatureCapability `xml:"audit_control"`
	AuditWrite     *DomainFeatureCapability `xml:"audit_write"`
	BlockSuspend   *DomainFeatureCapability `xml:"block_suspend"`
	Chown          *DomainFeatureCapability `xml:"chown"`
	DACOverride    *DomainFeatureCapability `xml:"dac_override"`
	DACReadSearch  *DomainFeatureCapability `xml:"dac_read_Search"`
	FOwner         *DomainFeatureCapability `xml:"fowner"`
	FSetID         *DomainFeatureCapability `xml:"fsetid"`
	IPCLock        *DomainFeatureCapability `xml:"ipc_lock"`
	IPCOwner       *DomainFeatureCapability `xml:"ipc_owner"`
	Kill           *DomainFeatureCapability `xml:"kill"`
	Lease          *DomainFeatureCapability `xml:"lease"`
	LinuxImmutable *DomainFeatureCapability `xml:"linux_immutable"`
	MACAdmin       *DomainFeatureCapability `xml:"mac_admin"`
	MACOverride    *DomainFeatureCapability `xml:"mac_override"`
	MkNod          *DomainFeatureCapability `xml:"mknod"`
	NetAdmin       *DomainFeatureCapability `xml:"net_admin"`
	NetBindService *DomainFeatureCapability `xml:"net_bind_service"`
	NetBroadcast   *DomainFeatureCapability `xml:"net_broadcast"`
	NetRaw         *DomainFeatureCapability `xml:"net_raw"`
	SetGID         *DomainFeatureCapability `xml:"setgid"`
	SetFCap        *DomainFeatureCapability `xml:"setfcap"`
	SetPCap        *DomainFeatureCapability `xml:"setpcap"`
	SetUID         *DomainFeatureCapability `xml:"setuid"`
	SysAdmin       *DomainFeatureCapability `xml:"sys_admin"`
	SysBoot        *DomainFeatureCapability `xml:"sys_boot"`
	SysChRoot      *DomainFeatureCapability `xml:"sys_chroot"`
	SysModule      *DomainFeatureCapability `xml:"sys_module"`
	SysNice        *DomainFeatureCapability `xml:"sys_nice"`
	SysPAcct       *DomainFeatureCapability `xml:"sys_pacct"`
	SysPTrace      *DomainFeatureCapability `xml:"sys_ptrace"`
	SysRawIO       *DomainFeatureCapability `xml:"sys_rawio"`
	SysResource    *DomainFeatureCapability `xml:"sys_resource"`
	SysTime        *DomainFeatureCapability `xml:"sys_time"`
	SysTTYCnofig   *DomainFeatureCapability `xml:"sys_tty_config"`
	SysLog         *DomainFeatureCapability `xml:"syslog"`
	WakeAlarm      *DomainFeatureCapability `xml:"wake_alarm"`
}

      type DomainFeatureCapability 

      type DomainFeatureCapability struct {
	State string `xml:"state,attr,omitempty"`
}

      type DomainFeatureGIC 

      type DomainFeatureGIC struct {
	Version string `xml:"version,attr,omitempty"`
}

      type DomainFeatureHPT 

      type DomainFeatureHPT struct {
	Resizing    string                    `xml:"resizing,attr,omitempty"`
	MaxPageSize *DomainFeatureHPTPageSize `xml:"maxpagesize"`
}

      type DomainFeatureHPTPageSize 

      type DomainFeatureHPTPageSize struct {
	Unit  string `xml:"unit,attr,omitempty"`
	Value string `xml:",chardata"`
}

      type DomainFeatureHyperV 

      type DomainFeatureHyperV struct {
	DomainFeature
	Relaxed         *DomainFeatureState           `xml:"relaxed"`
	VAPIC           *DomainFeatureState           `xml:"vapic"`
	Spinlocks       *DomainFeatureHyperVSpinlocks `xml:"spinlocks"`
	VPIndex         *DomainFeatureState           `xml:"vpindex"`
	Runtime         *DomainFeatureState           `xml:"runtime"`
	Synic           *DomainFeatureState           `xml:"synic"`
	STimer          *DomainFeatureHyperVSTimer    `xml:"stimer"`
	Reset           *DomainFeatureState           `xml:"reset"`
	VendorId        *DomainFeatureHyperVVendorId  `xml:"vendor_id"`
	Frequencies     *DomainFeatureState           `xml:"frequencies"`
	ReEnlightenment *DomainFeatureState           `xml:"reenlightenment"`
	TLBFlush        *DomainFeatureState           `xml:"tlbflush"`
	IPI             *DomainFeatureState           `xml:"ipi"`
	EVMCS           *DomainFeatureState           `xml:"evmcs"`
}

      type DomainFeatureHyperVSTimer 

      type DomainFeatureHyperVSTimer struct {
	DomainFeatureState
	Direct *DomainFeatureState `xml:"direct"`
}

      type DomainFeatureHyperVSpinlocks 

      type DomainFeatureHyperVSpinlocks struct {
	DomainFeatureState
	Retries uint `xml:"retries,attr,omitempty"`
}

      type DomainFeatureHyperVVendorId 

      type DomainFeatureHyperVVendorId struct {
	DomainFeatureState
	Value string `xml:"value,attr,omitempty"`
}

      type DomainFeatureIBS 

      type DomainFeatureIBS struct {
	Value string `xml:"value,attr"`
}

      type DomainFeatureIOAPIC 

      type DomainFeatureIOAPIC struct {
	Driver string `xml:"driver,attr,omitempty"`
}

      type DomainFeatureKVM 

      type DomainFeatureKVM struct {
	Hidden        *DomainFeatureState `xml:"hidden"`
	HintDedicated *DomainFeatureState `xml:"hint-dedicated"`
	PollControl   *DomainFeatureState `xml:"poll-control"`
}

      type DomainFeatureList 

      type DomainFeatureList struct {
	PAE          *DomainFeature             `xml:"pae"`
	ACPI         *DomainFeature             `xml:"acpi"`
	APIC         *DomainFeatureAPIC         `xml:"apic"`
	HAP          *DomainFeatureState        `xml:"hap"`
	Viridian     *DomainFeature             `xml:"viridian"`
	PrivNet      *DomainFeature             `xml:"privnet"`
	HyperV       *DomainFeatureHyperV       `xml:"hyperv"`
	KVM          *DomainFeatureKVM          `xml:"kvm"`
	Xen          *DomainFeatureXen          `xml:"xen"`
	PVSpinlock   *DomainFeatureState        `xml:"pvspinlock"`
	PMU          *DomainFeatureState        `xml:"pmu"`
	VMPort       *DomainFeatureState        `xml:"vmport"`
	GIC          *DomainFeatureGIC          `xml:"gic"`
	SMM          *DomainFeatureSMM          `xml:"smm"`
	IOAPIC       *DomainFeatureIOAPIC       `xml:"ioapic"`
	HPT          *DomainFeatureHPT          `xml:"hpt"`
	HTM          *DomainFeatureState        `xml:"htm"`
	NestedHV     *DomainFeatureState        `xml:"nested-hv"`
	Capabilities *DomainFeatureCapabilities `xml:"capabilities"`
	VMCoreInfo   *DomainFeatureState        `xml:"vmcoreinfo"`
	MSRS         *DomainFeatureMSRS         `xml:"msrs"`
	CCFAssist    *DomainFeatureState        `xml:"ccf-assist"`
	CFPC         *DomainFeatureCFPC         `xml:"cfpc"`
	SBBC         *DomainFeatureSBBC         `xml:"sbbc"`
	IBS          *DomainFeatureIBS          `xml:"ibs"`
}

      type DomainFeatureMSRS 

      type DomainFeatureMSRS struct {
	Unknown string `xml:"unknown,attr"`
}

      type DomainFeatureSBBC 

      type DomainFeatureSBBC struct {
	Value string `xml:"value,attr"`
}

      type DomainFeatureSMM 

      type DomainFeatureSMM struct {
	State string                `xml:"state,attr,omitempty"`
	TSeg  *DomainFeatureSMMTSeg `xml:"tseg"`
}

      type DomainFeatureSMMTSeg 

      type DomainFeatureSMMTSeg struct {
	Unit  string `xml:"unit,attr,omitempty"`
	Value uint   `xml:",chardata"`
}

      type DomainFeatureState 

      type DomainFeatureState struct {
	State string `xml:"state,attr,omitempty"`
}

      type DomainFeatureXen 

      type DomainFeatureXen struct {
	E820Host    *DomainFeatureXenE820Host    `xml:"e820_host"`
	Passthrough *DomainFeatureXenPassthrough `xml:"passthrough"`
}

      type DomainFeatureXenE820Host 

      type DomainFeatureXenE820Host struct {
	State string `xml:"state,attr"`
}

      type DomainFeatureXenPassthrough 

      type DomainFeatureXenPassthrough struct {
	State string `xml:"state,attr,omitempty"`
	Mode  string `xml:"mode,attr,omitempty"`
}

      type DomainFilesystem 

      type DomainFilesystem struct {
	XMLName        xml.Name                        `xml:"filesystem"`
	AccessMode     string                          `xml:"accessmode,attr,omitempty"`
	Model          string                          `xml:"model,attr,omitempty"`
	MultiDevs      string                          `xml:"multidevs,attr,omitempty"`
	FMode          string                          `xml:"fmode,attr,omitempty"`
	DMode          string                          `xml:"dmode,attr,omitempty"`
	Driver         *DomainFilesystemDriver         `xml:"driver"`
	Binary         *DomainFilesystemBinary         `xml:"binary"`
	Source         *DomainFilesystemSource         `xml:"source"`
	Target         *DomainFilesystemTarget         `xml:"target"`
	ReadOnly       *DomainFilesystemReadOnly       `xml:"readonly"`
	SpaceHardLimit *DomainFilesystemSpaceHardLimit `xml:"space_hard_limit"`
	SpaceSoftLimit *DomainFilesystemSpaceSoftLimit `xml:"space_soft_limit"`
	Boot           *DomainDeviceBoot               `xml:"boot"`
	Alias          *DomainAlias                    `xml:"alias"`
	Address        *DomainAddress                  `xml:"address"`
}

      func (*DomainFilesystem) Marshal 

      func (d *DomainFilesystem) Marshal() (string, error)

      func (*DomainFilesystem) MarshalXML 

      func (a *DomainFilesystem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainFilesystem) Unmarshal 

      func (d *DomainFilesystem) Unmarshal(doc string) error

      func (*DomainFilesystem) UnmarshalXML 

      func (a *DomainFilesystem) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainFilesystemBinary 

      type DomainFilesystemBinary struct {
	Path  string                       `xml:"path,attr,omitempty"`
	XAttr string                       `xml:"xattr,attr,omitempty"`
	Cache *DomainFilesystemBinaryCache `xml:"cache"`
	Lock  *DomainFilesystemBinaryLock  `xml:"lock"`
}

      type DomainFilesystemBinaryCache 

      type DomainFilesystemBinaryCache struct {
	Mode string `xml:"mode,attr"`
}

      type DomainFilesystemBinaryLock 

      type DomainFilesystemBinaryLock struct {
	POSIX string `xml:"posix,attr,omitempty"`
	Flock string `xml:"flock,attr,omitempty"`
}

      type DomainFilesystemDriver 

      type DomainFilesystemDriver struct {
	Type     string `xml:"type,attr,omitempty"`
	Format   string `xml:"format,attr,omitempty"`
	Name     string `xml:"name,attr,omitempty"`
	WRPolicy string `xml:"wrpolicy,attr,omitempty"`
	IOMMU    string `xml:"iommu,attr,omitempty"`
	ATS      string `xml:"ats,attr,omitempty"`
	Packed   string `xml:"packed,attr,omitempty"`
	Queue    uint   `xml:"queue,attr,omitempty"`
}

      type DomainFilesystemReadOnly 

      type DomainFilesystemReadOnly struct {
}

      type DomainFilesystemSource 

      type DomainFilesystemSource struct {
	Mount    *DomainFilesystemSourceMount    `xml:"-"`
	Block    *DomainFilesystemSourceBlock    `xml:"-"`
	File     *DomainFilesystemSourceFile     `xml:"-"`
	Template *DomainFilesystemSourceTemplate `xml:"-"`
	RAM      *DomainFilesystemSourceRAM      `xml:"-"`
	Bind     *DomainFilesystemSourceBind     `xml:"-"`
	Volume   *DomainFilesystemSourceVolume   `xml:"-"`
}

      func (*DomainFilesystemSource) MarshalXML 

      func (a *DomainFilesystemSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainFilesystemSource) UnmarshalXML 

      func (a *DomainFilesystemSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainFilesystemSourceBind 

      type DomainFilesystemSourceBind struct {
	Dir string `xml:"dir,attr"`
}

      type DomainFilesystemSourceBlock 

      type DomainFilesystemSourceBlock struct {
	Dev string `xml:"dev,attr"`
}

      type DomainFilesystemSourceFile 

      type DomainFilesystemSourceFile struct {
	File string `xml:"file,attr"`
}

      type DomainFilesystemSourceMount 

      type DomainFilesystemSourceMount struct {
	Dir string `xml:"dir,attr"`
}

      type DomainFilesystemSourceRAM 

      type DomainFilesystemSourceRAM struct {
	Usage uint   `xml:"usage,attr"`
	Units string `xml:"units,attr,omitempty"`
}

      type DomainFilesystemSourceTemplate 

      type DomainFilesystemSourceTemplate struct {
	Name string `xml:"name,attr"`
}

      type DomainFilesystemSourceVolume 

      type DomainFilesystemSourceVolume struct {
	Pool   string `xml:"pool,attr"`
	Volume string `xml:"volume,attr"`
}

      type DomainFilesystemSpaceHardLimit 

      type DomainFilesystemSpaceHardLimit struct {
	Value uint   `xml:",chardata"`
	Unit  string `xml:"unit,attr,omitempty"`
}

      type DomainFilesystemSpaceSoftLimit 

      type DomainFilesystemSpaceSoftLimit struct {
	Value uint   `xml:",chardata"`
	Unit  string `xml:"unit,attr,omitempty"`
}

      type DomainFilesystemTarget 

      type DomainFilesystemTarget struct {
	Dir string `xml:"dir,attr"`
}

      type DomainGenID 

      type DomainGenID struct {
	Value string `xml:",chardata"`
}

      type DomainGraphic 

      type DomainGraphic struct {
	XMLName     xml.Name                  `xml:"graphics"`
	SDL         *DomainGraphicSDL         `xml:"-"`
	VNC         *DomainGraphicVNC         `xml:"-"`
	RDP         *DomainGraphicRDP         `xml:"-"`
	Desktop     *DomainGraphicDesktop     `xml:"-"`
	Spice       *DomainGraphicSpice       `xml:"-"`
	EGLHeadless *DomainGraphicEGLHeadless `xml:"-"`
}

      func (*DomainGraphic) Marshal 

      func (d *DomainGraphic) Marshal() (string, error)

      func (*DomainGraphic) MarshalXML 

      func (a *DomainGraphic) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainGraphic) Unmarshal 

      func (d *DomainGraphic) Unmarshal(doc string) error

      func (*DomainGraphic) UnmarshalXML 

      func (a *DomainGraphic) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainGraphicChannel 

      type DomainGraphicChannel struct {
	Name string `xml:"name,attr,omitempty"`
	Mode string `xml:"mode,attr,omitempty"`
}

      type DomainGraphicDesktop 

      type DomainGraphicDesktop struct {
	Display    string `xml:"display,attr,omitempty"`
	FullScreen string `xml:"fullscreen,attr,omitempty"`
}

      type DomainGraphicEGLHeadless 

      type DomainGraphicEGLHeadless struct {
	GL *DomainGraphicEGLHeadlessGL `xml:"gl"`
}

      type DomainGraphicEGLHeadlessGL 

      type DomainGraphicEGLHeadlessGL struct {
	RenderNode string `xml:"rendernode,attr,omitempty"`
}

      type DomainGraphicFileTransfer 

      type DomainGraphicFileTransfer struct {
	Enable string `xml:"enable,attr,omitempty"`
}

      type DomainGraphicListener 

      type DomainGraphicListener struct {
	Address *DomainGraphicListenerAddress `xml:"-"`
	Network *DomainGraphicListenerNetwork `xml:"-"`
	Socket  *DomainGraphicListenerSocket  `xml:"-"`
}

      func (*DomainGraphicListener) MarshalXML 

      func (a *DomainGraphicListener) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainGraphicListener) UnmarshalXML 

      func (a *DomainGraphicListener) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainGraphicListenerAddress 

      type DomainGraphicListenerAddress struct {
	Address string `xml:"address,attr,omitempty"`
}

      type DomainGraphicListenerNetwork 

      type DomainGraphicListenerNetwork struct {
	Address string `xml:"address,attr,omitempty"`
	Network string `xml:"network,attr,omitempty"`
}

      type DomainGraphicListenerSocket 

      type DomainGraphicListenerSocket struct {
	Socket string `xml:"socket,attr,omitempty"`
}

      type DomainGraphicRDP 

      type DomainGraphicRDP struct {
	Port        int                     `xml:"port,attr,omitempty"`
	AutoPort    string                  `xml:"autoport,attr,omitempty"`
	ReplaceUser string                  `xml:"replaceUser,attr,omitempty"`
	MultiUser   string                  `xml:"multiUser,attr,omitempty"`
	Listen      string                  `xml:"listen,attr,omitempty"`
	Listeners   []DomainGraphicListener `xml:"listen"`
}

      type DomainGraphicSDL 

      type DomainGraphicSDL struct {
	Display    string               `xml:"display,attr,omitempty"`
	XAuth      string               `xml:"xauth,attr,omitempty"`
	FullScreen string               `xml:"fullscreen,attr,omitempty"`
	GL         *DomainGraphicsSDLGL `xml:"gl"`
}

      type DomainGraphicSpice 

      type DomainGraphicSpice struct {
	Port          int                             `xml:"port,attr,omitempty"`
	TLSPort       int                             `xml:"tlsPort,attr,omitempty"`
	AutoPort      string                          `xml:"autoport,attr,omitempty"`
	Listen        string                          `xml:"listen,attr,omitempty"`
	Keymap        string                          `xml:"keymap,attr,omitempty"`
	DefaultMode   string                          `xml:"defaultMode,attr,omitempty"`
	Passwd        string                          `xml:"passwd,attr,omitempty"`
	PasswdValidTo string                          `xml:"passwdValidTo,attr,omitempty"`
	Connected     string                          `xml:"connected,attr,omitempty"`
	Listeners     []DomainGraphicListener         `xml:"listen"`
	Channel       []DomainGraphicSpiceChannel     `xml:"channel"`
	Image         *DomainGraphicSpiceImage        `xml:"image"`
	JPEG          *DomainGraphicSpiceJPEG         `xml:"jpeg"`
	ZLib          *DomainGraphicSpiceZLib         `xml:"zlib"`
	Playback      *DomainGraphicSpicePlayback     `xml:"playback"`
	Streaming     *DomainGraphicSpiceStreaming    `xml:"streaming"`
	Mouse         *DomainGraphicSpiceMouse        `xml:"mouse"`
	ClipBoard     *DomainGraphicSpiceClipBoard    `xml:"clipboard"`
	FileTransfer  *DomainGraphicSpiceFileTransfer `xml:"filetransfer"`
	GL            *DomainGraphicSpiceGL           `xml:"gl"`
}

      type DomainGraphicSpiceChannel 

      type DomainGraphicSpiceChannel struct {
	Name string `xml:"name,attr"`
	Mode string `xml:"mode,attr"`
}

      type DomainGraphicSpiceClipBoard 

      type DomainGraphicSpiceClipBoard struct {
	CopyPaste string `xml:"copypaste,attr"`
}

      type DomainGraphicSpiceFileTransfer 

      type DomainGraphicSpiceFileTransfer struct {
	Enable string `xml:"enable,attr"`
}

      type DomainGraphicSpiceGL 

      type DomainGraphicSpiceGL struct {
	Enable     string `xml:"enable,attr,omitempty"`
	RenderNode string `xml:"rendernode,attr,omitempty"`
}

      type DomainGraphicSpiceImage 

      type DomainGraphicSpiceImage struct {
	Compression string `xml:"compression,attr"`
}

      type DomainGraphicSpiceJPEG 

      type DomainGraphicSpiceJPEG struct {
	Compression string `xml:"compression,attr"`
}

      type DomainGraphicSpiceMouse 

      type DomainGraphicSpiceMouse struct {
	Mode string `xml:"mode,attr"`
}

      type DomainGraphicSpicePlayback 

      type DomainGraphicSpicePlayback struct {
	Compression string `xml:"compression,attr"`
}

      type DomainGraphicSpiceStreaming 

      type DomainGraphicSpiceStreaming struct {
	Mode string `xml:"mode,attr"`
}

      type DomainGraphicSpiceZLib 

      type DomainGraphicSpiceZLib struct {
	Compression string `xml:"compression,attr"`
}

      type DomainGraphicVNC 

      type DomainGraphicVNC struct {
	Socket        string                  `xml:"socket,attr,omitempty"`
	Port          int                     `xml:"port,attr,omitempty"`
	AutoPort      string                  `xml:"autoport,attr,omitempty"`
	WebSocket     int                     `xml:"websocket,attr,omitempty"`
	Keymap        string                  `xml:"keymap,attr,omitempty"`
	SharePolicy   string                  `xml:"sharePolicy,attr,omitempty"`
	Passwd        string                  `xml:"passwd,attr,omitempty"`
	PasswdValidTo string                  `xml:"passwdValidTo,attr,omitempty"`
	Connected     string                  `xml:"connected,attr,omitempty"`
	Listen        string                  `xml:"listen,attr,omitempty"`
	Listeners     []DomainGraphicListener `xml:"listen"`
}

      type DomainGraphicsSDLGL 

      type DomainGraphicsSDLGL struct {
	Enable string `xml:"enable,attr,omitempty"`
}

      type DomainHostdev 

      type DomainHostdev struct {
	Managed        string                       `xml:"managed,attr,omitempty"`
	SubsysUSB      *DomainHostdevSubsysUSB      `xml:"-"`
	SubsysSCSI     *DomainHostdevSubsysSCSI     `xml:"-"`
	SubsysSCSIHost *DomainHostdevSubsysSCSIHost `xml:"-"`
	SubsysPCI      *DomainHostdevSubsysPCI      `xml:"-"`
	SubsysMDev     *DomainHostdevSubsysMDev     `xml:"-"`
	CapsStorage    *DomainHostdevCapsStorage    `xml:"-"`
	CapsMisc       *DomainHostdevCapsMisc       `xml:"-"`
	CapsNet        *DomainHostdevCapsNet        `xml:"-"`
	Boot           *DomainDeviceBoot            `xml:"boot"`
	ROM            *DomainROM                   `xml:"rom"`
	Alias          *DomainAlias                 `xml:"alias"`
	Address        *DomainAddress               `xml:"address"`
}

      func (*DomainHostdev) Marshal 

      func (d *DomainHostdev) Marshal() (string, error)

      func (*DomainHostdev) MarshalXML 

      func (a *DomainHostdev) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainHostdev) Unmarshal 

      func (d *DomainHostdev) Unmarshal(doc string) error

      func (*DomainHostdev) UnmarshalXML 

      func (a *DomainHostdev) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainHostdevCapsMisc 

      type DomainHostdevCapsMisc struct {
	Source *DomainHostdevCapsMiscSource `xml:"source"`
}

      type DomainHostdevCapsMiscSource 

      type DomainHostdevCapsMiscSource struct {
	Char string `xml:"char"`
}

      type DomainHostdevCapsNet 

      type DomainHostdevCapsNet struct {
	Source *DomainHostdevCapsNetSource `xml:"source"`
	IP     []DomainIP                  `xml:"ip"`
	Route  []DomainRoute               `xml:"route"`
}

      type DomainHostdevCapsNetSource 

      type DomainHostdevCapsNetSource struct {
	Interface string `xml:"interface"`
}

      type DomainHostdevCapsStorage 

      type DomainHostdevCapsStorage struct {
	Source *DomainHostdevCapsStorageSource `xml:"source"`
}

      type DomainHostdevCapsStorageSource 

      type DomainHostdevCapsStorageSource struct {
	Block string `xml:"block"`
}

      type DomainHostdevSubsysMDev 

      type DomainHostdevSubsysMDev struct {
	Model   string                         `xml:"model,attr,omitempty"`
	Display string                         `xml:"display,attr,omitempty"`
	RamFB   string                         `xml:"ramfb,attr,omitempty"`
	Source  *DomainHostdevSubsysMDevSource `xml:"source"`
}

      type DomainHostdevSubsysMDevSource 

      type DomainHostdevSubsysMDevSource struct {
	Address *DomainAddressMDev `xml:"address"`
}

      type DomainHostdevSubsysPCI 

      type DomainHostdevSubsysPCI struct {
	Driver  *DomainHostdevSubsysPCIDriver `xml:"driver"`
	Source  *DomainHostdevSubsysPCISource `xml:"source"`
	Teaming *DomainInterfaceTeaming       `xml:"teaming"`
}

      type DomainHostdevSubsysPCIDriver 

      type DomainHostdevSubsysPCIDriver struct {
	Name string `xml:"name,attr,omitempty"`
}

      type DomainHostdevSubsysPCISource 

      type DomainHostdevSubsysPCISource struct {
	WriteFiltering string            `xml:"writeFiltering,attr,omitempty"`
	Address        *DomainAddressPCI `xml:"address"`
}

      type DomainHostdevSubsysSCSI 

      type DomainHostdevSubsysSCSI struct {
	SGIO      string                         `xml:"sgio,attr,omitempty"`
	RawIO     string                         `xml:"rawio,attr,omitempty"`
	Source    *DomainHostdevSubsysSCSISource `xml:"source"`
	ReadOnly  *DomainDiskReadOnly            `xml:"readonly"`
	Shareable *DomainDiskShareable           `xml:"shareable"`
}

      type DomainHostdevSubsysSCSIAdapter 

      type DomainHostdevSubsysSCSIAdapter struct {
	Name string `xml:"name,attr"`
}

      type DomainHostdevSubsysSCSIHost 

      type DomainHostdevSubsysSCSIHost struct {
	Model  string                             `xml:"model,attr,omitempty"`
	Source *DomainHostdevSubsysSCSIHostSource `xml:"source"`
}

      type DomainHostdevSubsysSCSIHostSource 

      type DomainHostdevSubsysSCSIHostSource struct {
	Protocol string `xml:"protocol,attr,omitempty"`
	WWPN     string `xml:"wwpn,attr,omitempty"`
}

      type DomainHostdevSubsysSCSISource 

      type DomainHostdevSubsysSCSISource struct {
	Host  *DomainHostdevSubsysSCSISourceHost  `xml:"-"`
	ISCSI *DomainHostdevSubsysSCSISourceISCSI `xml:"-"`
}

      func (*DomainHostdevSubsysSCSISource) MarshalXML 

      func (a *DomainHostdevSubsysSCSISource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainHostdevSubsysSCSISource) UnmarshalXML 

      func (a *DomainHostdevSubsysSCSISource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainHostdevSubsysSCSISourceHost 

      type DomainHostdevSubsysSCSISourceHost struct {
	Adapter *DomainHostdevSubsysSCSIAdapter `xml:"adapter"`
	Address *DomainAddressDrive             `xml:"address"`
}

      type DomainHostdevSubsysSCSISourceIQN 

      type DomainHostdevSubsysSCSISourceIQN struct {
	Name string `xml:"name,attr"`
}

      type DomainHostdevSubsysSCSISourceISCSI 

      type DomainHostdevSubsysSCSISourceISCSI struct {
	Name      string                                  `xml:"name,attr"`
	Host      []DomainDiskSourceHost                  `xml:"host"`
	Auth      *DomainDiskAuth                         `xml:"auth"`
	Initiator *DomainHostdevSubsysSCSISourceInitiator `xml:"initiator"`
}

      type DomainHostdevSubsysSCSISourceInitiator 

      type DomainHostdevSubsysSCSISourceInitiator struct {
	IQN DomainHostdevSubsysSCSISourceIQN `xml:"iqn"`
}

      type DomainHostdevSubsysUSB 

      type DomainHostdevSubsysUSB struct {
	Source *DomainHostdevSubsysUSBSource `xml:"source"`
}

      type DomainHostdevSubsysUSBSource 

      type DomainHostdevSubsysUSBSource struct {
	Address *DomainAddressUSB `xml:"address"`
}

      type DomainHub 

      type DomainHub struct {
	Type    string         `xml:"type,attr"`
	Alias   *DomainAlias   `xml:"alias"`
	Address *DomainAddress `xml:"address"`
}

      type DomainIDMap 

      type DomainIDMap struct {
	UIDs []DomainIDMapRange `xml:"uid"`
	GIDs []DomainIDMapRange `xml:"gid"`
}

      type DomainIDMapRange 

      type DomainIDMapRange struct {
	Start  uint `xml:"start,attr"`
	Target uint `xml:"target,attr"`
	Count  uint `xml:"count,attr"`
}

      type DomainIOMMU 

      type DomainIOMMU struct {
	Model  string             `xml:"model,attr"`
	Driver *DomainIOMMUDriver `xml:"driver"`
}

      type DomainIOMMUDriver 

      type DomainIOMMUDriver struct {
	IntRemap    string `xml:"intremap,attr,omitempty"`
	CachingMode string `xml:"caching_mode,attr,omitempty"`
	EIM         string `xml:"eim,attr,omitempty"`
	IOTLB       string `xml:"iotlb,attr,omitempty"`
	AWBits      uint   `xml:"aw_bits,attr,omitempty"`
}

      type DomainIOThread 

      type DomainIOThread struct {
	ID uint `xml:"id,attr"`
}

      type DomainIOThreadIDs 

      type DomainIOThreadIDs struct {
	IOThreads []DomainIOThread `xml:"iothread"`
}

      type DomainIP 

      type DomainIP struct {
	Address string `xml:"address,attr,omitempty"`
	Family  string `xml:"family,attr,omitempty"`
	Prefix  *uint  `xml:"prefix,attr"`
}

      type DomainInput 

      type DomainInput struct {
	XMLName xml.Name           `xml:"input"`
	Type    string             `xml:"type,attr"`
	Bus     string             `xml:"bus,attr,omitempty"`
	Model   string             `xml:"model,attr,omitempty"`
	Driver  *DomainInputDriver `xml:"driver"`
	Source  *DomainInputSource `xml:"source"`
	Alias   *DomainAlias       `xml:"alias"`
	Address *DomainAddress     `xml:"address"`
}

      func (*DomainInput) Marshal 

      func (d *DomainInput) Marshal() (string, error)

      func (*DomainInput) Unmarshal 

      func (d *DomainInput) Unmarshal(doc string) error

      type DomainInputDriver 

      type DomainInputDriver struct {
	IOMMU  string `xml:"iommu,attr,omitempty"`
	ATS    string `xml:"ats,attr,omitempty"`
	Packed string `xml:"packed,attr,omitempty"`
}

      type DomainInputSource 

      type DomainInputSource struct {
	EVDev string `xml:"evdev,attr"`
}

      type DomainInterface 

      type DomainInterface struct {
	XMLName             xml.Name                    `xml:"interface"`
	Managed             string                      `xml:"managed,attr,omitempty"`
	TrustGuestRXFilters string                      `xml:"trustGuestRxFilters,attr,omitempty"`
	MAC                 *DomainInterfaceMAC         `xml:"mac"`
	Source              *DomainInterfaceSource      `xml:"source"`
	Boot                *DomainDeviceBoot           `xml:"boot"`
	VLan                *DomainInterfaceVLan        `xml:"vlan"`
	VirtualPort         *DomainInterfaceVirtualPort `xml:"virtualport"`
	IP                  []DomainInterfaceIP         `xml:"ip"`
	Route               []DomainInterfaceRoute      `xml:"route"`
	Script              *DomainInterfaceScript      `xml:"script"`
	DownScript          *DomainInterfaceScript      `xml:"downscript"`
	BackendDomain       *DomainBackendDomain        `xml:"backenddomain"`
	Target              *DomainInterfaceTarget      `xml:"target"`
	Guest               *DomainInterfaceGuest       `xml:"guest"`
	Model               *DomainInterfaceModel       `xml:"model"`
	Driver              *DomainInterfaceDriver      `xml:"driver"`
	Backend             *DomainInterfaceBackend     `xml:"backend"`
	FilterRef           *DomainInterfaceFilterRef   `xml:"filterref"`
	Tune                *DomainInterfaceTune        `xml:"tune"`
	Teaming             *DomainInterfaceTeaming     `xml:"teaming"`
	Link                *DomainInterfaceLink        `xml:"link"`
	MTU                 *DomainInterfaceMTU         `xml:"mtu"`
	Bandwidth           *DomainInterfaceBandwidth   `xml:"bandwidth"`
	PortOptions         *DomainInterfacePortOptions `xml:"port"`
	Coalesce            *DomainInterfaceCoalesce    `xml:"coalesce"`
	ROM                 *DomainROM                  `xml:"rom"`
	Alias               *DomainAlias                `xml:"alias"`
	Address             *DomainAddress              `xml:"address"`
}

      func (*DomainInterface) Marshal 

      func (d *DomainInterface) Marshal() (string, error)

      func (*DomainInterface) MarshalXML 

      func (a *DomainInterface) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainInterface) Unmarshal 

      func (d *DomainInterface) Unmarshal(doc string) error

      func (*DomainInterface) UnmarshalXML 

      func (a *DomainInterface) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainInterfaceBackend 

      type DomainInterfaceBackend struct {
	Tap   string `xml:"tap,attr,omitempty"`
	VHost string `xml:"vhost,attr,omitempty"`
}

      type DomainInterfaceBandwidth 

      type DomainInterfaceBandwidth struct {
	Inbound  *DomainInterfaceBandwidthParams `xml:"inbound"`
	Outbound *DomainInterfaceBandwidthParams `xml:"outbound"`
}

      type DomainInterfaceBandwidthParams 

      type DomainInterfaceBandwidthParams struct {
	Average *int `xml:"average,attr"`
	Peak    *int `xml:"peak,attr"`
	Burst   *int `xml:"burst,attr"`
	Floor   *int `xml:"floor,attr"`
}

      type DomainInterfaceCoalesce 

      type DomainInterfaceCoalesce struct {
	RX *DomainInterfaceCoalesceRX `xml:"rx"`
}

      type DomainInterfaceCoalesceRX 

      type DomainInterfaceCoalesceRX struct {
	Frames *DomainInterfaceCoalesceRXFrames `xml:"frames"`
}

      type DomainInterfaceCoalesceRXFrames 

      type DomainInterfaceCoalesceRXFrames struct {
	Max *uint `xml:"max,attr"`
}

      type DomainInterfaceDriver 

      type DomainInterfaceDriver struct {
	Name        string                      `xml:"name,attr,omitempty"`
	TXMode      string                      `xml:"txmode,attr,omitempty"`
	IOEventFD   string                      `xml:"ioeventfd,attr,omitempty"`
	EventIDX    string                      `xml:"event_idx,attr,omitempty"`
	Queues      uint                        `xml:"queues,attr,omitempty"`
	RXQueueSize uint                        `xml:"rx_queue_size,attr,omitempty"`
	TXQueueSize uint                        `xml:"tx_queue_size,attr,omitempty"`
	IOMMU       string                      `xml:"iommu,attr,omitempty"`
	ATS         string                      `xml:"ats,attr,omitempty"`
	Packed      string                      `xml:"packed,attr,omitempty"`
	Host        *DomainInterfaceDriverHost  `xml:"host"`
	Guest       *DomainInterfaceDriverGuest `xml:"guest"`
}

      type DomainInterfaceDriverGuest 

      type DomainInterfaceDriverGuest struct {
	CSum string `xml:"csum,attr,omitempty"`
	TSO4 string `xml:"tso4,attr,omitempty"`
	TSO6 string `xml:"tso6,attr,omitempty"`
	ECN  string `xml:"ecn,attr,omitempty"`
	UFO  string `xml:"ufo,attr,omitempty"`
}

      type DomainInterfaceDriverHost 

      type DomainInterfaceDriverHost struct {
	CSum     string `xml:"csum,attr,omitempty"`
	GSO      string `xml:"gso,attr,omitempty"`
	TSO4     string `xml:"tso4,attr,omitempty"`
	TSO6     string `xml:"tso6,attr,omitempty"`
	ECN      string `xml:"ecn,attr,omitempty"`
	UFO      string `xml:"ufo,attr,omitempty"`
	MrgRXBuf string `xml:"mrg_rxbuf,attr,omitempty"`
}

      type DomainInterfaceFilterParam 

      type DomainInterfaceFilterParam struct {
	Name  string `xml:"name,attr"`
	Value string `xml:"value,attr"`
}

      type DomainInterfaceFilterRef 

      type DomainInterfaceFilterRef struct {
	Filter     string                       `xml:"filter,attr"`
	Parameters []DomainInterfaceFilterParam `xml:"parameter"`
}

      type DomainInterfaceGuest 

      type DomainInterfaceGuest struct {
	Dev    string `xml:"dev,attr,omitempty"`
	Actual string `xml:"actual,attr,omitempty"`
}

      type DomainInterfaceIP 

      type DomainInterfaceIP struct {
	Address string `xml:"address,attr"`
	Family  string `xml:"family,attr,omitempty"`
	Prefix  uint   `xml:"prefix,attr,omitempty"`
	Peer    string `xml:"peer,attr,omitempty"`
}
      type DomainInterfaceLink struct {
	State string `xml:"state,attr"`
}

      type DomainInterfaceMAC 

      type DomainInterfaceMAC struct {
	Address string `xml:"address,attr"`
	Type    string `xml:"type,attr,omitempty"`
	Check   string `xml:"check,attr,omitempty"`
}

      type DomainInterfaceMTU 

      type DomainInterfaceMTU struct {
	Size uint `xml:"size,attr"`
}

      type DomainInterfaceModel 

      type DomainInterfaceModel struct {
	Type string `xml:"type,attr"`
}

      type DomainInterfacePortOptions 

      type DomainInterfacePortOptions struct {
	Isolated string `xml:"isolated,attr,omitempty"`
}

      type DomainInterfaceRoute 

      type DomainInterfaceRoute struct {
	Family  string `xml:"family,attr,omitempty"`
	Address string `xml:"address,attr"`
	Netmask string `xml:"netmask,attr,omitempty"`
	Prefix  uint   `xml:"prefix,attr,omitempty"`
	Gateway string `xml:"gateway,attr"`
	Metric  uint   `xml:"metric,attr,omitempty"`
}

      type DomainInterfaceScript 

      type DomainInterfaceScript struct {
	Path string `xml:"path,attr"`
}

      type DomainInterfaceSource 

      type DomainInterfaceSource struct {
	User      *DomainInterfaceSourceUser     `xml:"-"`
	Ethernet  *DomainInterfaceSourceEthernet `xml:"-"`
	VHostUser *DomainChardevSource           `xml:"-"`
	Server    *DomainInterfaceSourceServer   `xml:"-"`
	Client    *DomainInterfaceSourceClient   `xml:"-"`
	MCast     *DomainInterfaceSourceMCast    `xml:"-"`
	Network   *DomainInterfaceSourceNetwork  `xml:"-"`
	Bridge    *DomainInterfaceSourceBridge   `xml:"-"`
	Internal  *DomainInterfaceSourceInternal `xml:"-"`
	Direct    *DomainInterfaceSourceDirect   `xml:"-"`
	Hostdev   *DomainInterfaceSourceHostdev  `xml:"-"`
	UDP       *DomainInterfaceSourceUDP      `xml:"-"`
	VDPA      *DomainInterfaceSourceVDPA     `xml:"-"`
}

      func (*DomainInterfaceSource) MarshalXML 

      func (a *DomainInterfaceSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainInterfaceSource) UnmarshalXML 

      func (a *DomainInterfaceSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainInterfaceSourceBridge 

      type DomainInterfaceSourceBridge struct {
	Bridge string `xml:"bridge,attr"`
}

      type DomainInterfaceSourceClient 

      type DomainInterfaceSourceClient struct {
	Address string                      `xml:"address,attr,omitempty"`
	Port    uint                        `xml:"port,attr,omitempty"`
	Local   *DomainInterfaceSourceLocal `xml:"local"`
}

      type DomainInterfaceSourceDirect 

      type DomainInterfaceSourceDirect struct {
	Dev  string `xml:"dev,attr,omitempty"`
	Mode string `xml:"mode,attr,omitempty"`
}

      type DomainInterfaceSourceEthernet 

      type DomainInterfaceSourceEthernet struct {
	IP    []DomainInterfaceIP    `xml:"ip"`
	Route []DomainInterfaceRoute `xml:"route"`
}

      type DomainInterfaceSourceHostdev 

      type DomainInterfaceSourceHostdev struct {
	PCI *DomainHostdevSubsysPCISource `xml:"-"`
	USB *DomainHostdevSubsysUSBSource `xml:"-"`
}

      func (*DomainInterfaceSourceHostdev) MarshalXML 

      func (a *DomainInterfaceSourceHostdev) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainInterfaceSourceHostdev) UnmarshalXML 

      func (a *DomainInterfaceSourceHostdev) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainInterfaceSourceInternal 

      type DomainInterfaceSourceInternal struct {
	Name string `xml:"name,attr,omitempty"`
}

      type DomainInterfaceSourceLocal 

      type DomainInterfaceSourceLocal struct {
	Address string `xml:"address,attr,omitempty"`
	Port    uint   `xml:"port,attr,omitempty"`
}

      type DomainInterfaceSourceMCast 

      type DomainInterfaceSourceMCast struct {
	Address string                      `xml:"address,attr,omitempty"`
	Port    uint                        `xml:"port,attr,omitempty"`
	Local   *DomainInterfaceSourceLocal `xml:"local"`
}

      type DomainInterfaceSourceNetwork 

      type DomainInterfaceSourceNetwork struct {
	Network   string `xml:"network,attr,omitempty"`
	PortGroup string `xml:"portgroup,attr,omitempty"`
	Bridge    string `xml:"bridge,attr,omitempty"`
	PortID    string `xml:"portid,attr,omitempty"`
}

      type DomainInterfaceSourceServer 

      type DomainInterfaceSourceServer struct {
	Address string                      `xml:"address,attr,omitempty"`
	Port    uint                        `xml:"port,attr,omitempty"`
	Local   *DomainInterfaceSourceLocal `xml:"local"`
}

      type DomainInterfaceSourceUDP 

      type DomainInterfaceSourceUDP struct {
	Address string                      `xml:"address,attr,omitempty"`
	Port    uint                        `xml:"port,attr,omitempty"`
	Local   *DomainInterfaceSourceLocal `xml:"local"`
}

      type DomainInterfaceSourceUser 

      type DomainInterfaceSourceUser struct {
}

      type DomainInterfaceSourceVDPA 

      type DomainInterfaceSourceVDPA struct {
	Device string `xml:"dev,attr,omitempty"`
}

      type DomainInterfaceTarget 

      type DomainInterfaceTarget struct {
	Dev     string `xml:"dev,attr"`
	Managed string `xml:"managed,attr,omitempty"`
}

      type DomainInterfaceTeaming 

      type DomainInterfaceTeaming struct {
	Type       string `xml:"type,attr"`
	Persistent string `xml:"persistent,attr,omitempty"`
}

      type DomainInterfaceTune 

      type DomainInterfaceTune struct {
	SndBuf uint `xml:"sndbuf"`
}

      type DomainInterfaceVLan 

      type DomainInterfaceVLan struct {
	Trunk string                   `xml:"trunk,attr,omitempty"`
	Tags  []DomainInterfaceVLanTag `xml:"tag"`
}

      type DomainInterfaceVLanTag 

      type DomainInterfaceVLanTag struct {
	ID         uint   `xml:"id,attr"`
	NativeMode string `xml:"nativeMode,attr,omitempty"`
}

      type DomainInterfaceVirtualPort 

      type DomainInterfaceVirtualPort struct {
	Params *DomainInterfaceVirtualPortParams `xml:"parameters"`
}

      func (*DomainInterfaceVirtualPort) MarshalXML 

      func (a *DomainInterfaceVirtualPort) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainInterfaceVirtualPort) UnmarshalXML 

      func (a *DomainInterfaceVirtualPort) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainInterfaceVirtualPortParams 

      type DomainInterfaceVirtualPortParams struct {
	Any          *DomainInterfaceVirtualPortParamsAny          `xml:"-"`
	VEPA8021QBG  *DomainInterfaceVirtualPortParamsVEPA8021QBG  `xml:"-"`
	VNTag8011QBH *DomainInterfaceVirtualPortParamsVNTag8021QBH `xml:"-"`
	OpenVSwitch  *DomainInterfaceVirtualPortParamsOpenVSwitch  `xml:"-"`
	MidoNet      *DomainInterfaceVirtualPortParamsMidoNet      `xml:"-"`
}

      func (*DomainInterfaceVirtualPortParams) MarshalXML 

      func (a *DomainInterfaceVirtualPortParams) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainInterfaceVirtualPortParams) UnmarshalXML 

      func (a *DomainInterfaceVirtualPortParams) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainInterfaceVirtualPortParamsAny 

      type DomainInterfaceVirtualPortParamsAny struct {
	ManagerID     *uint  `xml:"managerid,attr"`
	TypeID        *uint  `xml:"typeid,attr"`
	TypeIDVersion *uint  `xml:"typeidversion,attr"`
	InstanceID    string `xml:"instanceid,attr,omitempty"`
	ProfileID     string `xml:"profileid,attr,omitempty"`
	InterfaceID   string `xml:"interfaceid,attr,omitempty"`
}

      type DomainInterfaceVirtualPortParamsMidoNet 

      type DomainInterfaceVirtualPortParamsMidoNet struct {
	InterfaceID string `xml:"interfaceid,attr,omitempty"`
}

      type DomainInterfaceVirtualPortParamsOpenVSwitch 

      type DomainInterfaceVirtualPortParamsOpenVSwitch struct {
	InterfaceID string `xml:"interfaceid,attr,omitempty"`
	ProfileID   string `xml:"profileid,attr,omitempty"`
}

      type DomainInterfaceVirtualPortParamsVEPA8021QBG 

      type DomainInterfaceVirtualPortParamsVEPA8021QBG struct {
	ManagerID     *uint  `xml:"managerid,attr"`
	TypeID        *uint  `xml:"typeid,attr"`
	TypeIDVersion *uint  `xml:"typeidversion,attr"`
	InstanceID    string `xml:"instanceid,attr,omitempty"`
}

      type DomainInterfaceVirtualPortParamsVNTag8021QBH 

      type DomainInterfaceVirtualPortParamsVNTag8021QBH struct {
	ProfileID string `xml:"profileid,attr,omitempty"`
}

      type DomainKeyWrap 

      type DomainKeyWrap struct {
	Ciphers []DomainKeyWrapCipher `xml:"cipher"`
}

      type DomainKeyWrapCipher 

      type DomainKeyWrapCipher struct {
	Name  string `xml:"name,attr"`
	State string `xml:"state,attr"`
}

      type DomainLXCNamespace 

      type DomainLXCNamespace struct {
	XMLName  xml.Name               `xml:"http://libvirt.org/schemas/domain/lxc/1.0 namespace"`
	ShareNet *DomainLXCNamespaceMap `xml:"sharenet"`
	ShareIPC *DomainLXCNamespaceMap `xml:"shareipc"`
	ShareUTS *DomainLXCNamespaceMap `xml:"shareuts"`
}

      type DomainLXCNamespaceMap 

      type DomainLXCNamespaceMap struct {
	Type  string `xml:"type,attr"`
	Value string `xml:"value,attr"`
}

      type DomainLaunchSecurity 

      type DomainLaunchSecurity struct {
	SEV *DomainLaunchSecuritySEV `xml:"-"`
}

      func (*DomainLaunchSecurity) MarshalXML 

      func (a *DomainLaunchSecurity) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainLaunchSecurity) UnmarshalXML 

      func (a *DomainLaunchSecurity) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainLaunchSecuritySEV 

      type DomainLaunchSecuritySEV struct {
	CBitPos         *uint  `xml:"cbitpos"`
	ReducedPhysBits *uint  `xml:"reducedPhysBits"`
	Policy          *uint  `xml:"policy"`
	DHCert          string `xml:"dhCert"`
	Session         string `xml:"sesion"`
}

      func (*DomainLaunchSecuritySEV) MarshalXML 

      func (a *DomainLaunchSecuritySEV) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainLaunchSecuritySEV) UnmarshalXML 

      func (a *DomainLaunchSecuritySEV) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainLease 

      type DomainLease struct {
	Lockspace string             `xml:"lockspace"`
	Key       string             `xml:"key"`
	Target    *DomainLeaseTarget `xml:"target"`
}

      type DomainLeaseTarget 

      type DomainLeaseTarget struct {
	Path   string `xml:"path,attr"`
	Offset uint64 `xml:"offset,attr,omitempty"`
}

      type DomainLoader 

      type DomainLoader struct {
	Path     string `xml:",chardata"`
	Readonly string `xml:"readonly,attr,omitempty"`
	Secure   string `xml:"secure,attr,omitempty"`
	Type     string `xml:"type,attr,omitempty"`
}

      type DomainMaxMemory 

      type DomainMaxMemory struct {
	Value uint   `xml:",chardata"`
	Unit  string `xml:"unit,attr,omitempty"`
	Slots uint   `xml:"slots,attr,omitempty"`
}

      type DomainMemBalloon 

      type DomainMemBalloon struct {
	XMLName           xml.Name                `xml:"memballoon"`
	Model             string                  `xml:"model,attr"`
	AutoDeflate       string                  `xml:"autodeflate,attr,omitempty"`
	FreePageReporting string                  `xml:"freePageReporting,attr,omitempty"`
	Driver            *DomainMemBalloonDriver `xml:"driver"`
	Stats             *DomainMemBalloonStats  `xml:"stats"`
	Alias             *DomainAlias            `xml:"alias"`
	Address           *DomainAddress          `xml:"address"`
}

      func (*DomainMemBalloon) Marshal 

      func (d *DomainMemBalloon) Marshal() (string, error)

      func (*DomainMemBalloon) Unmarshal 

      func (d *DomainMemBalloon) Unmarshal(doc string) error

      type DomainMemBalloonDriver 

      type DomainMemBalloonDriver struct {
	IOMMU  string `xml:"iommu,attr,omitempty"`
	ATS    string `xml:"ats,attr,omitempty"`
	Packed string `xml:"packed,attr,omitempty"`
}

      type DomainMemBalloonStats 

      type DomainMemBalloonStats struct {
	Period uint `xml:"period,attr"`
}

      type DomainMemory 

      type DomainMemory struct {
	Value    uint   `xml:",chardata"`
	Unit     string `xml:"unit,attr,omitempty"`
	DumpCore string `xml:"dumpCore,attr,omitempty"`
}

      type DomainMemoryAccess 

      type DomainMemoryAccess struct {
	Mode string `xml:"mode,attr,omitempty"`
}

      type DomainMemoryAllocation 

      type DomainMemoryAllocation struct {
	Mode string `xml:"mode,attr,omitempty"`
}

      type DomainMemoryBacking 

      type DomainMemoryBacking struct {
	MemoryHugePages    *DomainMemoryHugepages    `xml:"hugepages"`
	MemoryNosharepages *DomainMemoryNosharepages `xml:"nosharepages"`
	MemoryLocked       *DomainMemoryLocked       `xml:"locked"`
	MemorySource       *DomainMemorySource       `xml:"source"`
	MemoryAccess       *DomainMemoryAccess       `xml:"access"`
	MemoryAllocation   *DomainMemoryAllocation   `xml:"allocation"`
	MemoryDiscard      *DomainMemoryDiscard      `xml:"discard"`
}

      type DomainMemoryDiscard 

      type DomainMemoryDiscard struct {
}

      type DomainMemoryHugepage 

      type DomainMemoryHugepage struct {
	Size    uint   `xml:"size,attr"`
	Unit    string `xml:"unit,attr,omitempty"`
	Nodeset string `xml:"nodeset,attr,omitempty"`
}

      type DomainMemoryHugepages 

      type DomainMemoryHugepages struct {
	Hugepages []DomainMemoryHugepage `xml:"page"`
}

      type DomainMemoryLocked 

      type DomainMemoryLocked struct {
}

      type DomainMemoryNosharepages 

      type DomainMemoryNosharepages struct {
}

      type DomainMemorySource 

      type DomainMemorySource struct {
	Type string `xml:"type,attr,omitempty"`
}

      type DomainMemoryTune 

      type DomainMemoryTune struct {
	HardLimit     *DomainMemoryTuneLimit `xml:"hard_limit"`
	SoftLimit     *DomainMemoryTuneLimit `xml:"soft_limit"`
	MinGuarantee  *DomainMemoryTuneLimit `xml:"min_guarantee"`
	SwapHardLimit *DomainMemoryTuneLimit `xml:"swap_hard_limit"`
}

      type DomainMemoryTuneLimit 

      type DomainMemoryTuneLimit struct {
	Value uint64 `xml:",chardata"`
	Unit  string `xml:"unit,attr,omitempty"`
}

      type DomainMemorydev 

      type DomainMemorydev struct {
	XMLName xml.Name               `xml:"memory"`
	Model   string                 `xml:"model,attr"`
	Access  string                 `xml:"access,attr,omitempty"`
	Discard string                 `xml:"discard,attr,omitempty"`
	UUID    string                 `xml:"uuid,omitempty"`
	Source  *DomainMemorydevSource `xml:"source"`
	Target  *DomainMemorydevTarget `xml:"target"`
	Alias   *DomainAlias           `xml:"alias"`
	Address *DomainAddress         `xml:"address"`
}

      func (*DomainMemorydev) Marshal 

      func (d *DomainMemorydev) Marshal() (string, error)

      func (*DomainMemorydev) Unmarshal 

      func (d *DomainMemorydev) Unmarshal(doc string) error

      type DomainMemorydevSource 

      type DomainMemorydevSource struct {
	NodeMask  string                          `xml:"nodemask,omitempty"`
	PageSize  *DomainMemorydevSourcePagesize  `xml:"pagesize"`
	Path      string                          `xml:"path,omitempty"`
	AlignSize *DomainMemorydevSourceAlignsize `xml:"alignsize"`
	PMem      *DomainMemorydevSourcePMem      `xml:"pmem"`
}

      type DomainMemorydevSourceAlignsize 

      type DomainMemorydevSourceAlignsize struct {
	Value uint64 `xml:",chardata"`
	Unit  string `xml:"unit,attr,omitempty"`
}

      type DomainMemorydevSourcePMem 

      type DomainMemorydevSourcePMem struct {
}

      type DomainMemorydevSourcePagesize 

      type DomainMemorydevSourcePagesize struct {
	Value uint64 `xml:",chardata"`
	Unit  string `xml:"unit,attr,omitempty"`
}

      type DomainMemorydevTarget 

      type DomainMemorydevTarget struct {
	Size     *DomainMemorydevTargetSize     `xml:"size"`
	Node     *DomainMemorydevTargetNode     `xml:"node"`
	Label    *DomainMemorydevTargetLabel    `xml:"label"`
	ReadOnly *DomainMemorydevTargetReadOnly `xml:"readonly"`
}

      type DomainMemorydevTargetLabel 

      type DomainMemorydevTargetLabel struct {
	Size *DomainMemorydevTargetSize `xml:"size"`
}

      type DomainMemorydevTargetNode 

      type DomainMemorydevTargetNode struct {
	Value uint `xml:",chardata"`
}

      type DomainMemorydevTargetReadOnly 

      type DomainMemorydevTargetReadOnly struct {
}

      type DomainMemorydevTargetSize 

      type DomainMemorydevTargetSize struct {
	Value uint   `xml:",chardata"`
	Unit  string `xml:"unit,attr,omitempty"`
}

      type DomainMetadata 

      type DomainMetadata struct {
	XML string `xml:",innerxml"`
}

      type DomainNUMAInterconnectBandwidth 

      type DomainNUMAInterconnectBandwidth struct {
	Initiator uint   `xml:"initiator,attr"`
	Target    uint   `xml:"target,attr"`
	Type      string `xml:"type,attr"`
	Value     uint   `xml:"value,attr"`
	Unit      string `xml:"unit,attr"`
}

      type DomainNUMAInterconnectLatency 

      type DomainNUMAInterconnectLatency struct {
	Initiator uint   `xml:"initiator,attr"`
	Target    uint   `xml:"target,attr"`
	Cache     uint   `xml:"cache,attr,omitempty"`
	Type      string `xml:"type,attr"`
	Value     uint   `xml:"value,attr"`
}

      type DomainNUMAInterconnects 

      type DomainNUMAInterconnects struct {
	Latencies  []DomainNUMAInterconnectLatency   `xml:"latency"`
	Bandwidths []DomainNUMAInterconnectBandwidth `xml:"bandwidth"`
}

      type DomainNUMATune 

      type DomainNUMATune struct {
	Memory   *DomainNUMATuneMemory   `xml:"memory"`
	MemNodes []DomainNUMATuneMemNode `xml:"memnode"`
}

      type DomainNUMATuneMemNode 

      type DomainNUMATuneMemNode struct {
	CellID  uint   `xml:"cellid,attr"`
	Mode    string `xml:"mode,attr"`
	Nodeset string `xml:"nodeset,attr"`
}

      type DomainNUMATuneMemory 

      type DomainNUMATuneMemory struct {
	Mode      string `xml:"mode,attr,omitempty"`
	Nodeset   string `xml:"nodeset,attr,omitempty"`
	Placement string `xml:"placement,attr,omitempty"`
}

      type DomainNVRAM 

      type DomainNVRAM struct {
	Alias   *DomainAlias   `xml:"alias"`
	Address *DomainAddress `xml:"address"`
}

      type DomainNVRam 

      type DomainNVRam struct {
	NVRam    string `xml:",chardata"`
	Template string `xml:"template,attr,omitempty"`
}

      type DomainNuma 

      type DomainNuma struct {
	Cell          []DomainCell             `xml:"cell"`
	Interconnects *DomainNUMAInterconnects `xml:"interconnects"`
}

      type DomainOS 

      type DomainOS struct {
	Type        *DomainOSType      `xml:"type"`
	Firmware    string             `xml:"firmware,attr,omitempty"`
	Init        string             `xml:"init,omitempty"`
	InitArgs    []string           `xml:"initarg"`
	InitEnv     []DomainOSInitEnv  `xml:"initenv"`
	InitDir     string             `xml:"initdir,omitempty"`
	InitUser    string             `xml:"inituser,omitempty"`
	InitGroup   string             `xml:"initgroup,omitempty"`
	Loader      *DomainLoader      `xml:"loader"`
	NVRam       *DomainNVRam       `xml:"nvram"`
	Kernel      string             `xml:"kernel,omitempty"`
	Initrd      string             `xml:"initrd,omitempty"`
	Cmdline     string             `xml:"cmdline,omitempty"`
	DTB         string             `xml:"dtb,omitempty"`
	ACPI        *DomainACPI        `xml:"acpi"`
	BootDevices []DomainBootDevice `xml:"boot"`
	BootMenu    *DomainBootMenu    `xml:"bootmenu"`
	BIOS        *DomainBIOS        `xml:"bios"`
	SMBios      *DomainSMBios      `xml:"smbios"`
}

      type DomainOSInitEnv 

      type DomainOSInitEnv struct {
	Name  string `xml:"name,attr"`
	Value string `xml:",chardata"`
}

      type DomainOSType 

      type DomainOSType struct {
	Arch    string `xml:"arch,attr,omitempty"`
	Machine string `xml:"machine,attr,omitempty"`
	Type    string `xml:",chardata"`
}

      type DomainPM 

      type DomainPM struct {
	SuspendToMem  *DomainPMPolicy `xml:"suspend-to-mem"`
	SuspendToDisk *DomainPMPolicy `xml:"suspend-to-disk"`
}

      type DomainPMPolicy 

      type DomainPMPolicy struct {
	Enabled string `xml:"enabled,attr"`
}

      type DomainPanic 

      type DomainPanic struct {
	XMLName xml.Name       `xml:"panic"`
	Model   string         `xml:"model,attr,omitempty"`
	Alias   *DomainAlias   `xml:"alias"`
	Address *DomainAddress `xml:"address"`
}

      type DomainParallel 

      type DomainParallel struct {
	XMLName  xml.Name               `xml:"parallel"`
	Source   *DomainChardevSource   `xml:"source"`
	Protocol *DomainChardevProtocol `xml:"protocol"`
	Target   *DomainParallelTarget  `xml:"target"`
	Log      *DomainChardevLog      `xml:"log"`
	Alias    *DomainAlias           `xml:"alias"`
	Address  *DomainAddress         `xml:"address"`
}

      func (*DomainParallel) Marshal 

      func (d *DomainParallel) Marshal() (string, error)

      func (*DomainParallel) MarshalXML 

      func (a *DomainParallel) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainParallel) Unmarshal 

      func (d *DomainParallel) Unmarshal(doc string) error

      func (*DomainParallel) UnmarshalXML 

      func (a *DomainParallel) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainParallelTarget 

      type DomainParallelTarget struct {
	Type string `xml:"type,attr,omitempty"`
	Port *uint  `xml:"port,attr"`
}

      type DomainPerf 

      type DomainPerf struct {
	Events []DomainPerfEvent `xml:"event"`
}

      type DomainPerfEvent 

      type DomainPerfEvent struct {
	Name    string `xml:"name,attr"`
	Enabled string `xml:"enabled,attr"`
}

      type DomainQEMUCapabilities 

      type DomainQEMUCapabilities struct {
	XMLName xml.Name                      `xml:"http://libvirt.org/schemas/domain/qemu/1.0 capabilities"`
	Add     []DomainQEMUCapabilitiesEntry `xml:"add"`
	Del     []DomainQEMUCapabilitiesEntry `xml:"del"`
}

      type DomainQEMUCapabilitiesEntry 

      type DomainQEMUCapabilitiesEntry struct {
	Name string `xml:"capability,attr"`
}

      type DomainQEMUCommandline 

      type DomainQEMUCommandline struct {
	XMLName xml.Name                   `xml:"http://libvirt.org/schemas/domain/qemu/1.0 commandline"`
	Args    []DomainQEMUCommandlineArg `xml:"arg"`
	Envs    []DomainQEMUCommandlineEnv `xml:"env"`
}

      type DomainQEMUCommandlineArg 

      type DomainQEMUCommandlineArg struct {
	Value string `xml:"value,attr"`
}

      type DomainQEMUCommandlineEnv 

      type DomainQEMUCommandlineEnv struct {
	Name  string `xml:"name,attr"`
	Value string `xml:"value,attr,omitempty"`
}

      type DomainRNG 

      type DomainRNG struct {
	XMLName xml.Name          `xml:"rng"`
	Model   string            `xml:"model,attr"`
	Driver  *DomainRNGDriver  `xml:"driver"`
	Rate    *DomainRNGRate    `xml:"rate"`
	Backend *DomainRNGBackend `xml:"backend"`
	Alias   *DomainAlias      `xml:"alias"`
	Address *DomainAddress    `xml:"address"`
}

      func (*DomainRNG) Marshal 

      func (d *DomainRNG) Marshal() (string, error)

      func (*DomainRNG) Unmarshal 

      func (d *DomainRNG) Unmarshal(doc string) error

      type DomainRNGBackend 

      type DomainRNGBackend struct {
	Random  *DomainRNGBackendRandom  `xml:"-"`
	EGD     *DomainRNGBackendEGD     `xml:"-"`
	BuiltIn *DomainRNGBackendBuiltIn `xml:"-"`
}

      func (*DomainRNGBackend) MarshalXML 

      func (a *DomainRNGBackend) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainRNGBackend) UnmarshalXML 

      func (a *DomainRNGBackend) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainRNGBackendBuiltIn 

      type DomainRNGBackendBuiltIn struct {
}

      type DomainRNGBackendEGD 

      type DomainRNGBackendEGD struct {
	Source   *DomainChardevSource   `xml:"source"`
	Protocol *DomainChardevProtocol `xml:"protocol"`
}

      func (*DomainRNGBackendEGD) MarshalXML 

      func (a *DomainRNGBackendEGD) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainRNGBackendEGD) UnmarshalXML 

      func (a *DomainRNGBackendEGD) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainRNGBackendRandom 

      type DomainRNGBackendRandom struct {
	Device string `xml:",chardata"`
}

      type DomainRNGDriver 

      type DomainRNGDriver struct {
	IOMMU  string `xml:"iommu,attr,omitempty"`
	ATS    string `xml:"ats,attr,omitempty"`
	Packed string `xml:"packed,attr,omitempty"`
}

      type DomainRNGRate 

      type DomainRNGRate struct {
	Bytes  uint `xml:"bytes,attr"`
	Period uint `xml:"period,attr,omitempty"`
}

      type DomainROM 

      type DomainROM struct {
	Bar     string `xml:"bar,attr,omitempty"`
	File    string `xml:"file,attr,omitempty"`
	Enabled string `xml:"enabled,attr,omitempty"`
}

      type DomainRedirDev 

      type DomainRedirDev struct {
	XMLName  xml.Name               `xml:"redirdev"`
	Bus      string                 `xml:"bus,attr,omitempty"`
	Source   *DomainChardevSource   `xml:"source"`
	Protocol *DomainChardevProtocol `xml:"protocol"`
	Boot     *DomainDeviceBoot      `xml:"boot"`
	Alias    *DomainAlias           `xml:"alias"`
	Address  *DomainAddress         `xml:"address"`
}

      func (*DomainRedirDev) Marshal 

      func (d *DomainRedirDev) Marshal() (string, error)

      func (*DomainRedirDev) MarshalXML 

      func (a *DomainRedirDev) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainRedirDev) Unmarshal 

      func (d *DomainRedirDev) Unmarshal(doc string) error

      func (*DomainRedirDev) UnmarshalXML 

      func (a *DomainRedirDev) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainRedirFilter 

      type DomainRedirFilter struct {
	USB []DomainRedirFilterUSB `xml:"usbdev"`
}

      type DomainRedirFilterUSB 

      type DomainRedirFilterUSB struct {
	Class   *uint  `xml:"class,attr"`
	Vendor  *uint  `xml:"vendor,attr"`
	Product *uint  `xml:"product,attr"`
	Version string `xml:"version,attr,omitempty"`
	Allow   string `xml:"allow,attr"`
}

      func (*DomainRedirFilterUSB) MarshalXML 

      func (a *DomainRedirFilterUSB) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainRedirFilterUSB) UnmarshalXML 

      func (a *DomainRedirFilterUSB) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainResource 

      type DomainResource struct {
	Partition string `xml:"partition,omitempty"`
}

      type DomainRoute 

      type DomainRoute struct {
	Family  string `xml:"family,attr,omitempty"`
	Address string `xml:"address,attr,omitempty"`
	Gateway string `xml:"gateway,attr,omitempty"`
}

      type DomainSMBios 

      type DomainSMBios struct {
	Mode string `xml:"mode,attr"`
}

      type DomainSecLabel 

      type DomainSecLabel struct {
	Type       string `xml:"type,attr,omitempty"`
	Model      string `xml:"model,attr,omitempty"`
	Relabel    string `xml:"relabel,attr,omitempty"`
	Label      string `xml:"label,omitempty"`
	ImageLabel string `xml:"imagelabel,omitempty"`
	BaseLabel  string `xml:"baselabel,omitempty"`
}

      type DomainSerial 

      type DomainSerial struct {
	XMLName  xml.Name               `xml:"serial"`
	Source   *DomainChardevSource   `xml:"source"`
	Protocol *DomainChardevProtocol `xml:"protocol"`
	Target   *DomainSerialTarget    `xml:"target"`
	Log      *DomainChardevLog      `xml:"log"`
	Alias    *DomainAlias           `xml:"alias"`
	Address  *DomainAddress         `xml:"address"`
}

      func (*DomainSerial) Marshal 

      func (d *DomainSerial) Marshal() (string, error)

      func (*DomainSerial) MarshalXML 

      func (a *DomainSerial) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainSerial) Unmarshal 

      func (d *DomainSerial) Unmarshal(doc string) error

      func (*DomainSerial) UnmarshalXML 

      func (a *DomainSerial) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainSerialTarget 

      type DomainSerialTarget struct {
	Type  string                   `xml:"type,attr,omitempty"`
	Port  *uint                    `xml:"port,attr"`
	Model *DomainSerialTargetModel `xml:"model"`
}

      type DomainSerialTargetModel 

      type DomainSerialTargetModel struct {
	Name string `xml:"name,attr,omitempty"`
}

      type DomainShmem 

      type DomainShmem struct {
	XMLName xml.Name           `xml:"shmem"`
	Name    string             `xml:"name,attr"`
	Role    string             `xml:"role,attr,omitempty"`
	Size    *DomainShmemSize   `xml:"size"`
	Model   *DomainShmemModel  `xml:"model"`
	Server  *DomainShmemServer `xml:"server"`
	MSI     *DomainShmemMSI    `xml:"msi"`
	Alias   *DomainAlias       `xml:"alias"`
	Address *DomainAddress     `xml:"address"`
}

      func (*DomainShmem) Marshal 

      func (d *DomainShmem) Marshal() (string, error)

      func (*DomainShmem) Unmarshal 

      func (d *DomainShmem) Unmarshal(doc string) error

      type DomainShmemMSI 

      type DomainShmemMSI struct {
	Enabled   string `xml:"enabled,attr,omitempty"`
	Vectors   uint   `xml:"vectors,attr,omitempty"`
	IOEventFD string `xml:"ioeventfd,attr,omitempty"`
}

      type DomainShmemModel 

      type DomainShmemModel struct {
	Type string `xml:"type,attr"`
}

      type DomainShmemServer 

      type DomainShmemServer struct {
	Path string `xml:"path,attr,omitempty"`
}

      type DomainShmemSize 

      type DomainShmemSize struct {
	Value uint   `xml:",chardata"`
	Unit  string `xml:"unit,attr,omitempty"`
}

      type DomainSmartcard 

      type DomainSmartcard struct {
	XMLName     xml.Name                  `xml:"smartcard"`
	Passthrough *DomainChardevSource      `xml:"source"`
	Protocol    *DomainChardevProtocol    `xml:"protocol"`
	Host        *DomainSmartcardHost      `xml:"-"`
	HostCerts   []DomainSmartcardHostCert `xml:"certificate"`
	Database    string                    `xml:"database,omitempty"`
	Alias       *DomainAlias              `xml:"alias"`
	Address     *DomainAddress            `xml:"address"`
}

      func (*DomainSmartcard) Marshal 

      func (d *DomainSmartcard) Marshal() (string, error)

      func (*DomainSmartcard) MarshalXML 

      func (a *DomainSmartcard) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainSmartcard) Unmarshal 

      func (d *DomainSmartcard) Unmarshal(doc string) error

      func (*DomainSmartcard) UnmarshalXML 

      func (a *DomainSmartcard) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainSmartcardHost 

      type DomainSmartcardHost struct {
}

      type DomainSmartcardHostCert 

      type DomainSmartcardHostCert struct {
	File string `xml:",chardata"`
}

      type DomainSnapshot 

      type DomainSnapshot struct {
	XMLName      xml.Name              `xml:"domainsnapshot"`
	Name         string                `xml:"name,omitempty"`
	Description  string                `xml:"description,omitempty"`
	State        string                `xml:"state,omitempty"`
	CreationTime string                `xml:"creationTime,omitempty"`
	Parent       *DomainSnapshotParent `xml:"parent"`
	Memory       *DomainSnapshotMemory `xml:"memory"`
	Disks        *DomainSnapshotDisks  `xml:"disks"`
	Domain       *Domain               `xml:"domain"`
	Active       *uint                 `xml:"active"`
}

      func (*DomainSnapshot) Marshal 

      func (s *DomainSnapshot) Marshal() (string, error)

      func (*DomainSnapshot) Unmarshal 

      func (s *DomainSnapshot) Unmarshal(doc string) error

      type DomainSnapshotDisk 

      type DomainSnapshotDisk struct {
	Name     string            `xml:"name,attr"`
	Snapshot string            `xml:"snapshot,attr,omitempty"`
	Driver   *DomainDiskDriver `xml:"driver"`
	Source   *DomainDiskSource `xml:"source"`
}

      func (*DomainSnapshotDisk) MarshalXML 

      func (a *DomainSnapshotDisk) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainSnapshotDisk) UnmarshalXML 

      func (a *DomainSnapshotDisk) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainSnapshotDisks 

      type DomainSnapshotDisks struct {
	Disks []DomainSnapshotDisk `xml:"disk"`
}

      type DomainSnapshotMemory 

      type DomainSnapshotMemory struct {
	Snapshot string `xml:"snapshot,attr"`
	File     string `xml:"file,attr,omitempty"`
}

      type DomainSnapshotParent 

      type DomainSnapshotParent struct {
	Name string `xml:"name"`
}

      type DomainSound 

      type DomainSound struct {
	XMLName xml.Name           `xml:"sound"`
	Model   string             `xml:"model,attr"`
	Codec   []DomainSoundCodec `xml:"codec"`
	Audio   *DomainSoundAudio  `xml:"audio"`
	Alias   *DomainAlias       `xml:"alias"`
	Address *DomainAddress     `xml:"address"`
}

      func (*DomainSound) Marshal 

      func (d *DomainSound) Marshal() (string, error)

      func (*DomainSound) Unmarshal 

      func (d *DomainSound) Unmarshal(doc string) error

      type DomainSoundAudio 

      type DomainSoundAudio struct {
	ID uint `xml:"id,attr"`
}

      type DomainSoundCodec 

      type DomainSoundCodec struct {
	Type string `xml:"type,attr"`
}

      type DomainSysInfo 

      type DomainSysInfo struct {
	SMBIOS *DomainSysInfoSMBIOS `xml:"-"`
	FWCfg  *DomainSysInfoFWCfg  `xml:"-"`
}

      func (*DomainSysInfo) MarshalXML 

      func (a *DomainSysInfo) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainSysInfo) UnmarshalXML 

      func (a *DomainSysInfo) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainSysInfoBIOS 

      type DomainSysInfoBIOS struct {
	Entry []DomainSysInfoEntry `xml:"entry"`
}

      type DomainSysInfoBaseBoard 

      type DomainSysInfoBaseBoard struct {
	Entry []DomainSysInfoEntry `xml:"entry"`
}

      type DomainSysInfoChassis 

      type DomainSysInfoChassis struct {
	Entry []DomainSysInfoEntry `xml:"entry"`
}

      type DomainSysInfoEntry 

      type DomainSysInfoEntry struct {
	Name  string `xml:"name,attr"`
	File  string `xml:"file,attr,omitempty"`
	Value string `xml:",chardata"`
}

      type DomainSysInfoFWCfg 

      type DomainSysInfoFWCfg struct {
	Entry []DomainSysInfoEntry `xml:"entry"`
}

      type DomainSysInfoMemory 

      type DomainSysInfoMemory struct {
	Entry []DomainSysInfoEntry `xml:"entry"`
}

      type DomainSysInfoOEMStrings 

      type DomainSysInfoOEMStrings struct {
	Entry []string `xml:"entry"`
}

      type DomainSysInfoProcessor 

      type DomainSysInfoProcessor struct {
	Entry []DomainSysInfoEntry `xml:"entry"`
}

      type DomainSysInfoSMBIOS 

      type DomainSysInfoSMBIOS struct {
	BIOS       *DomainSysInfoBIOS       `xml:"bios"`
	System     *DomainSysInfoSystem     `xml:"system"`
	BaseBoard  []DomainSysInfoBaseBoard `xml:"baseBoard"`
	Chassis    *DomainSysInfoChassis    `xml:"chassis"`
	Processor  []DomainSysInfoProcessor `xml:"processor"`
	Memory     []DomainSysInfoMemory    `xml:"memory"`
	OEMStrings *DomainSysInfoOEMStrings `xml:"oemStrings"`
}

      type DomainSysInfoSystem 

      type DomainSysInfoSystem struct {
	Entry []DomainSysInfoEntry `xml:"entry"`
}

      type DomainTPM 

      type DomainTPM struct {
	XMLName xml.Name          `xml:"tpm"`
	Model   string            `xml:"model,attr,omitempty"`
	Backend *DomainTPMBackend `xml:"backend"`
	Alias   *DomainAlias      `xml:"alias"`
	Address *DomainAddress    `xml:"address"`
}

      func (*DomainTPM) Marshal 

      func (d *DomainTPM) Marshal() (string, error)

      func (*DomainTPM) Unmarshal 

      func (d *DomainTPM) Unmarshal(doc string) error

      type DomainTPMBackend 

      type DomainTPMBackend struct {
	Passthrough *DomainTPMBackendPassthrough `xml:"-"`
	Emulator    *DomainTPMBackendEmulator    `xml:"-"`
}

      func (*DomainTPMBackend) MarshalXML 

      func (a *DomainTPMBackend) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*DomainTPMBackend) UnmarshalXML 

      func (a *DomainTPMBackend) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type DomainTPMBackendDevice 

      type DomainTPMBackendDevice struct {
	Path string `xml:"path,attr"`
}

      type DomainTPMBackendEmulator 

      type DomainTPMBackendEmulator struct {
	Version         string                      `xml:"version,attr,omitempty"`
	Encryption      *DomainTPMBackendEncryption `xml:"encryption"`
	PersistentState string                      `xml:"persistent_state,attr,omitempty"`
}

      type DomainTPMBackendEncryption 

      type DomainTPMBackendEncryption struct {
	Secret string `xml:"secret,attr"`
}

      type DomainTPMBackendPassthrough 

      type DomainTPMBackendPassthrough struct {
	Device *DomainTPMBackendDevice `xml:"device"`
}

      type DomainTimer 

      type DomainTimer struct {
	Name       string              `xml:"name,attr"`
	Track      string              `xml:"track,attr,omitempty"`
	TickPolicy string              `xml:"tickpolicy,attr,omitempty"`
	CatchUp    *DomainTimerCatchUp `xml:"catchup"`
	Frequency  uint64              `xml:"frequency,attr,omitempty"`
	Mode       string              `xml:"mode,attr,omitempty"`
	Present    string              `xml:"present,attr,omitempty"`
}

      type DomainTimerCatchUp 

      type DomainTimerCatchUp struct {
	Threshold uint `xml:"threshold,attr,omitempty"`
	Slew      uint `xml:"slew,attr,omitempty"`
	Limit     uint `xml:"limit,attr,omitempty"`
}

      type DomainVCPU 

      type DomainVCPU struct {
	Placement string `xml:"placement,attr,omitempty"`
	CPUSet    string `xml:"cpuset,attr,omitempty"`
	Current   uint   `xml:"current,attr,omitempty"`
	Value     uint   `xml:",chardata"`
}

      type DomainVCPUs 

      type DomainVCPUs struct {
	VCPU []DomainVCPUsVCPU `xml:"vcpu"`
}

      type DomainVCPUsVCPU 

      type DomainVCPUsVCPU struct {
	Id           *uint  `xml:"id,attr"`
	Enabled      string `xml:"enabled,attr,omitempty"`
	Hotpluggable string `xml:"hotpluggable,attr,omitempty"`
	Order        *uint  `xml:"order,attr"`
}

      type DomainVMWareDataCenterPath 

      type DomainVMWareDataCenterPath struct {
	XMLName xml.Name `xml:"http://libvirt.org/schemas/domain/vmware/1.0 datacenterpath"`
	Value   string   `xml:",chardata"`
}

      type DomainVSock 

      type DomainVSock struct {
	XMLName xml.Name           `xml:"vsock"`
	Model   string             `xml:"model,attr,omitempty"`
	CID     *DomainVSockCID    `xml:"cid"`
	Driver  *DomainVSockDriver `xml:"driver"`
	Alias   *DomainAlias       `xml:"alias"`
	Address *DomainAddress     `xml:"address"`
}

      func (*DomainVSock) Marshal 

      func (d *DomainVSock) Marshal() (string, error)

      func (*DomainVSock) Unmarshal 

      func (d *DomainVSock) Unmarshal(doc string) error

      type DomainVSockCID 

      type DomainVSockCID struct {
	Auto    string `xml:"auto,attr,omitempty"`
	Address string `xml:"address,attr,omitempty"`
}

      type DomainVSockDriver 

      type DomainVSockDriver struct {
	IOMMU  string `xml:"iommu,attr,omitempty"`
	ATS    string `xml:"ats,attr,omitempty"`
	Packed string `xml:"packed,attr,omitempty"`
}

      type DomainVideo 

      type DomainVideo struct {
	XMLName xml.Name           `xml:"video"`
	Model   DomainVideoModel   `xml:"model"`
	Driver  *DomainVideoDriver `xml:"driver"`
	Alias   *DomainAlias       `xml:"alias"`
	Address *DomainAddress     `xml:"address"`
}

      func (*DomainVideo) Marshal 

      func (d *DomainVideo) Marshal() (string, error)

      func (*DomainVideo) Unmarshal 

      func (d *DomainVideo) Unmarshal(doc string) error

      type DomainVideoAccel 

      type DomainVideoAccel struct {
	Accel3D    string `xml:"accel3d,attr,omitempty"`
	Accel2D    string `xml:"accel2d,attr,omitempty"`
	RenderNode string `xml:"rendernode,attr,omitempty"`
}

      type DomainVideoDriver 

      type DomainVideoDriver struct {
	Name    string `xml:"name,attr,omitempty"`
	VGAConf string `xml:"vgaconf,attr,omitempty"`
	IOMMU   string `xml:"iommu,attr,omitempty"`
	ATS     string `xml:"ats,attr,omitempty"`
	Packed  string `xml:"packed,attr,omitempty"`
}

      type DomainVideoModel 

      type DomainVideoModel struct {
	Type       string                 `xml:"type,attr"`
	Heads      uint                   `xml:"heads,attr,omitempty"`
	Ram        uint                   `xml:"ram,attr,omitempty"`
	VRam       uint                   `xml:"vram,attr,omitempty"`
	VRam64     uint                   `xml:"vram64,attr,omitempty"`
	VGAMem     uint                   `xml:"vgamem,attr,omitempty"`
	Primary    string                 `xml:"primary,attr,omitempty"`
	Accel      *DomainVideoAccel      `xml:"acceleration"`
	Resolution *DomainVideoResolution `xml:"resolution"`
}

      type DomainVideoResolution 

      type DomainVideoResolution struct {
	X uint `xml:"x,attr"`
	Y uint `xml:"y,attr"`
}

      type DomainWatchdog 

      type DomainWatchdog struct {
	XMLName xml.Name       `xml:"watchdog"`
	Model   string         `xml:"model,attr"`
	Action  string         `xml:"action,attr,omitempty"`
	Alias   *DomainAlias   `xml:"alias"`
	Address *DomainAddress `xml:"address"`
}

      func (*DomainWatchdog) Marshal 

      func (d *DomainWatchdog) Marshal() (string, error)

      func (*DomainWatchdog) Unmarshal 

      func (d *DomainWatchdog) Unmarshal(doc string) error

      type DomainXenCommandline 

      type DomainXenCommandline struct {
	XMLName xml.Name                  `xml:"http://libvirt.org/schemas/domain/xen/1.0 commandline"`
	Args    []DomainXenCommandlineArg `xml:"arg"`
}

      type DomainXenCommandlineArg 

      type DomainXenCommandlineArg struct {
	Value string `xml:"value,attr"`
}

      type Interface 

      type Interface struct {
	XMLName  xml.Name            `xml:"interface"`
	Name     string              `xml:"name,attr,omitempty"`
	Start    *InterfaceStart     `xml:"start"`
	MTU      *InterfaceMTU       `xml:"mtu"`
	Protocol []InterfaceProtocol `xml:"protocol"`
	Link     *InterfaceLink      `xml:"link"`
	MAC      *InterfaceMAC       `xml:"mac"`
	Bond     *InterfaceBond      `xml:"bond"`
	Bridge   *InterfaceBridge    `xml:"bridge"`
	VLAN     *InterfaceVLAN      `xml:"vlan"`
}

      func (*Interface) Marshal 

      func (s *Interface) Marshal() (string, error)

      func (*Interface) MarshalXML 

      func (s *Interface) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*Interface) Unmarshal 

      func (s *Interface) Unmarshal(doc string) error

      type InterfaceAutoConf 

      type InterfaceAutoConf struct {
}

      type InterfaceBond 

      type InterfaceBond struct {
	Mode       string               `xml:"mode,attr,omitempty"`
	ARPMon     *InterfaceBondARPMon `xml:"arpmon"`
	MIIMon     *InterfaceBondMIIMon `xml:"miimon"`
	Interfaces []Interface          `xml:"interface"`
}

      type InterfaceBondARPMon 

      type InterfaceBondARPMon struct {
	Interval uint   `xml:"interval,attr,omitempty"`
	Target   string `xml:"target,attr,omitempty"`
	Validate string `xml:"validate,attr,omitempty"`
}

      type InterfaceBondMIIMon 

      type InterfaceBondMIIMon struct {
	Freq    uint   `xml:"freq,attr,omitempty"`
	UpDelay uint   `xml:"updelay,attr,omitempty"`
	Carrier string `xml:"carrier,attr,omitempty"`
}

      type InterfaceBridge 

      type InterfaceBridge struct {
	STP        string      `xml:"stp,attr,omitempty"`
	Delay      *float64    `xml:"delay,attr"`
	Interfaces []Interface `xml:"interface"`
}

      type InterfaceDHCP 

      type InterfaceDHCP struct {
	PeerDNS string `xml:"peerdns,attr,omitempty"`
}

      type InterfaceIP 

      type InterfaceIP struct {
	Address string `xml:"address,attr"`
	Prefix  uint   `xml:"prefix,attr,omitempty"`
}
      type InterfaceLink struct {
	Speed uint   `xml:"speed,attr,omitempty"`
	State string `xml:"state,attr,omitempty"`
}

      type InterfaceMAC 

      type InterfaceMAC struct {
	Address string `xml:"address,attr"`
}

      type InterfaceMTU 

      type InterfaceMTU struct {
	Size uint `xml:"size,attr"`
}

      type InterfaceProtocol 

      type InterfaceProtocol struct {
	Family   string             `xml:"family,attr,omitempty"`
	AutoConf *InterfaceAutoConf `xml:"autoconf"`
	DHCP     *InterfaceDHCP     `xml:"dhcp"`
	IPs      []InterfaceIP      `xml:"ip"`
	Route    []InterfaceRoute   `xml:"route"`
}

      type InterfaceRoute 

      type InterfaceRoute struct {
	Gateway string `xml:"gateway,attr"`
}

      type InterfaceStart 

      type InterfaceStart struct {
	Mode string `xml:"mode,attr"`
}

      type InterfaceVLAN 

      type InterfaceVLAN struct {
	Tag       *uint      `xml:"tag,attr"`
	Interface *Interface `xml:"interface"`
}

      type NWFilter 

      type NWFilter struct {
	XMLName  xml.Name `xml:"filter"`
	Name     string   `xml:"name,attr"`
	UUID     string   `xml:"uuid,omitempty"`
	Chain    string   `xml:"chain,attr,omitempty"`
	Priority int      `xml:"priority,attr,omitempty"`
	Entries  []NWFilterEntry
}

      func (*NWFilter) Marshal 

      func (s *NWFilter) Marshal() (string, error)

      func (*NWFilter) MarshalXML 

      func (a *NWFilter) MarshalXML(e *xml.Encoder, start xml.StartElement) error

      func (*NWFilter) Unmarshal 

      func (s *NWFilter) Unmarshal(doc string) error

      func (*NWFilter) UnmarshalXML 

      func (a *NWFilter) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

      type NWFilterBinding 

      type NWFilterBinding struct {
	XMLName   xml.Name                  `xml:"filterbinding"`
	Owner     *NWFilterBindingOwner     `xml:"owner"`
	PortDev   *NWFilterBindingPortDev   `xml:"portdev"`
	MAC       *NWFilterBindingMAC       `xml:"mac"`
	FilterRef *NWFilterBindingFilterRef `xml:"filterref"`
}

      func (*NWFilterBinding) Marshal 

      func (s *NWFilterBinding) Marshal() (string, error)

      func (*NWFilterBinding) Unmarshal 

      func (s *NWFilterBinding) Unmarshal(doc string) error

      type NWFilterBindingFilterParam 

      type NWFilterBindingFilterParam struct {
	Name  string `xml:"name,attr"`
	Value string `xml:"value,attr"`
}

      type NWFilterBindingFilterRef 

      type NWFilterBindingFilterRef struct {
	Filter     string                       `xml:"filter,attr"`
	Parameters []NWFilterBindingFilterParam `xml:"parameter"`
}

      type NWFilterBindingMAC 

      type NWFilterBindingMAC struct {
	Address string `xml:"address,attr"`
}

      type NWFilterBindingOwner 

      type NWFilterBindingOwner struct {
	UUID string `xml:"uuid,omitempty"`
	Name string `xml:"name,omitempty"`
}

      type NWFilterBindingPortDev 

      type NWFilterBindingPortDev struct {
	Name string `xml:"name,attr"`
}

      type NWFilterEntry 

      type NWFilterEntry struct {
	Rule *NWFilterRule
	Ref  *NWFilterRef
}

      type NWFilterField 

      type NWFilterField struct {
	Var  string
	Str  string
	Uint *uint
}

      func (*NWFilterField) MarshalXMLAttr 

      func (s *NWFilterField) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

      func (*NWFilterField) UnmarshalXMLAttr 

      func (s *NWFilterField) UnmarshalXMLAttr(attr xml.Attr) error

      type NWFilterParameter 

      type NWFilterParameter struct {
	Name  string `xml:"name,attr"`
	Value string `xml:"value,attr"`
}

      type NWFilterRef 

      type NWFilterRef struct {
	Filter     string              `xml:"filter,attr"`
	Parameters []NWFilterParameter `xml:"parameter"`
}

      type NWFilterRule 

      type NWFilterRule struct {
	Action     string `xml:"action,attr,omitempty"`
	Direction  string `xml:"direction,attr,omitempty"`
	Priority   int    `xml:"priority,attr,omitempty"`
	StateMatch string `xml:"statematch,attr,omitempty"`

	ARP         *NWFilterRuleARP         `xml:"arp"`
	RARP        *NWFilterRuleRARP        `xml:"rarp"`
	MAC         *NWFilterRuleMAC         `xml:"mac"`
	VLAN        *NWFilterRuleVLAN        `xml:"vlan"`
	STP         *NWFilterRuleSTP         `xml:"stp"`
	IP          *NWFilterRuleIP          `xml:"ip"`
	IPv6        *NWFilterRuleIPv6        `xml:"ipv6"`
	TCP         *NWFilterRuleTCP         `xml:"tcp"`
	UDP         *NWFilterRuleUDP         `xml:"udp"`
	UDPLite     *NWFilterRuleUDPLite     `xml:"udplite"`
	ESP         *NWFilterRuleESP         `xml:"esp"`
	AH          *NWFilterRuleAH          `xml:"ah"`
	SCTP        *NWFilterRuleSCTP        `xml:"sctp"`
	ICMP        *NWFilterRuleICMP        `xml:"icmp"`
	All         *NWFilterRuleAll         `xml:"all"`
	IGMP        *NWFilterRuleIGMP        `xml:"igmp"`
	TCPIPv6     *NWFilterRuleTCPIPv6     `xml:"tcp-ipv6"`
	UDPIPv6     *NWFilterRuleUDPIPv6     `xml:"udp-ipv6"`
	UDPLiteIPv6 *NWFilterRuleUDPLiteIPv6 `xml:"udplite-ipv6"`
	ESPIPv6     *NWFilterRuleESPIPv6     `xml:"esp-ipv6"`
	AHIPv6      *NWFilterRuleAHIPv6      `xml:"ah-ipv6"`
	SCTPIPv6    *NWFilterRuleSCTPIPv6    `xml:"sctp-ipv6"`
	ICMPv6      *NWFilterRuleICMPIPv6    `xml:"icmpv6"`
	AllIPv6     *NWFilterRuleAllIPv6     `xml:"all-ipv6"`
}

      type NWFilterRuleAH 

      type NWFilterRuleAH struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	Comment string `xml:"comment,attr,omitempty"`
}

      type NWFilterRuleAHIPv6 

      type NWFilterRuleAHIPv6 struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	Comment string `xml:"comment,attr,omitempty"`
}

      type NWFilterRuleARP 

      type NWFilterRuleARP struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonMAC
	HWType        NWFilterField `xml:"hwtype,attr"`
	ProtocolType  NWFilterField `xml:"protocoltype,attr"`
	OpCode        NWFilterField `xml:"opcode,attr,omitempty"`
	ARPSrcMACAddr NWFilterField `xml:"arpsrcmacaddr,attr,omitempty"`
	ARPDstMACAddr NWFilterField `xml:"arpdstmacaddr,attr,omitempty"`
	ARPSrcIPAddr  NWFilterField `xml:"arpsrcipaddr,attr,omitempty"`
	ARPSrcIPMask  NWFilterField `xml:"arpsrcipmask,attr,omitempty"`
	ARPDstIPAddr  NWFilterField `xml:"arpdstipaddr,attr,omitempty"`
	ARPDstIPMask  NWFilterField `xml:"arpdstipmask,attr,omitempty"`
	Gratuitous    NWFilterField `xml:"gratuitous,attr,omitempty"`
	Comment       string        `xml:"comment,attr,omitempty"`
}

      type NWFilterRuleAll 

      type NWFilterRuleAll struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	Comment string `xml:"comment,attr,omitempty"`
}

      type NWFilterRuleAllIPv6 

      type NWFilterRuleAllIPv6 struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	Comment string `xml:"comment,attr,omitempty"`
}

      type NWFilterRuleCommonIP 

      type NWFilterRuleCommonIP struct {
	SrcMACAddr     NWFilterField `xml:"srcmacaddr,attr,omitempty"`
	SrcIPAddr      NWFilterField `xml:"srcipaddr,attr,omitempty"`
	SrcIPMask      NWFilterField `xml:"srcipmask,attr,omitempty"`
	DstIPAddr      NWFilterField `xml:"dstipaddr,attr,omitempty"`
	DstIPMask      NWFilterField `xml:"dstipmask,attr,omitempty"`
	SrcIPFrom      NWFilterField `xml:"srcipfrom,attr,omitempty"`
	SrcIPTo        NWFilterField `xml:"srcipto,attr,omitempty"`
	DstIPFrom      NWFilterField `xml:"dstipfrom,attr,omitempty"`
	DstIPTo        NWFilterField `xml:"dstipto,attr,omitempty"`
	DSCP           NWFilterField `xml:"dscp,attr"`
	ConnLimitAbove NWFilterField `xml:"connlimit-above,attr"`
	State          NWFilterField `xml:"state,attr,omitempty"`
	IPSet          NWFilterField `xml:"ipset,attr,omitempty"`
	IPSetFlags     NWFilterField `xml:"ipsetflags,attr,omitempty"`
}

      type NWFilterRuleCommonMAC 

      type NWFilterRuleCommonMAC struct {
	SrcMACAddr NWFilterField `xml:"srcmacaddr,attr,omitempty"`
	SrcMACMask NWFilterField `xml:"srcmacmask,attr,omitempty"`
	DstMACAddr NWFilterField `xml:"dstmacaddr,attr,omitempty"`
	DstMACMask NWFilterField `xml:"dstmacmask,attr,omitempty"`
}

      type NWFilterRuleCommonPort 

      type NWFilterRuleCommonPort struct {
	SrcPortStart NWFilterField `xml:"srcportstart,attr"`
	SrcPortEnd   NWFilterField `xml:"srcportend,attr"`
	DstPortStart NWFilterField `xml:"dstportstart,attr"`
	DstPortEnd   NWFilterField `xml:"dstportend,attr"`
}

      type NWFilterRuleESP 

      type NWFilterRuleESP struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	Comment string `xml:"comment,attr,omitempty"`
}

      type NWFilterRuleESPIPv6 

      type NWFilterRuleESPIPv6 struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	Comment string `xml:"comment,attr,omitempty"`
}

      type NWFilterRuleICMP 

      type NWFilterRuleICMP struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	Type    NWFilterField `xml:"type,attr"`
	Code    NWFilterField `xml:"code,attr"`
	Comment string        `xml:"comment,attr,omitempty"`
}

      type NWFilterRuleICMPIPv6 

      type NWFilterRuleICMPIPv6 struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	Type    NWFilterField `xml:"type,attr"`
	Code    NWFilterField `xml:"code,attr"`
	Comment string        `xml:"comment,attr,omitempty"`
}

      type NWFilterRuleIGMP 

      type NWFilterRuleIGMP struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	Comment string `xml:"comment,attr,omitempty"`
}

      type NWFilterRuleIP 

      type NWFilterRuleIP struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonMAC
	SrcIPAddr NWFilterField `xml:"srcipaddr,attr,omitempty"`
	SrcIPMask NWFilterField `xml:"srcipmask,attr,omitempty"`
	DstIPAddr NWFilterField `xml:"dstipaddr,attr,omitempty"`
	DstIPMask NWFilterField `xml:"dstipmask,attr,omitempty"`
	Protocol  NWFilterField `xml:"protocol,attr,omitempty"`
	NWFilterRuleCommonPort
	DSCP    NWFilterField `xml:"dscp,attr"`
	Comment string        `xml:"comment,attr,omitempty"`
}

      type NWFilterRuleIPv6 

      type NWFilterRuleIPv6 struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonMAC
	SrcIPAddr NWFilterField `xml:"srcipaddr,attr,omitempty"`
	SrcIPMask NWFilterField `xml:"srcipmask,attr,omitempty"`
	DstIPAddr NWFilterField `xml:"dstipaddr,attr,omitempty"`
	DstIPMask NWFilterField `xml:"dstipmask,attr,omitempty"`
	Protocol  NWFilterField `xml:"protocol,attr,omitempty"`
	NWFilterRuleCommonPort
	Type    NWFilterField `xml:"type,attr"`
	TypeEnd NWFilterField `xml:"typeend,attr"`
	Code    NWFilterField `xml:"code,attr"`
	CodeEnd NWFilterField `xml:"codeend,attr"`
	Comment string        `xml:"comment,attr,omitempty"`
}

      type NWFilterRuleMAC 

      type NWFilterRuleMAC struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonMAC
	ProtocolID NWFilterField `xml:"protocolid,attr,omitempty"`
	Comment    string        `xml:"comment,attr,omitempty"`
}

      type NWFilterRuleRARP 

      type NWFilterRuleRARP struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonMAC
	HWType        NWFilterField `xml:"hwtype,attr"`
	ProtocolType  NWFilterField `xml:"protocoltype,attr"`
	OpCode        NWFilterField `xml:"opcode,attr,omitempty"`
	ARPSrcMACAddr NWFilterField `xml:"arpsrcmacaddr,attr,omitempty"`
	ARPDstMACAddr NWFilterField `xml:"arpdstmacaddr,attr,omitempty"`
	ARPSrcIPAddr  NWFilterField `xml:"arpsrcipaddr,attr,omitempty"`
	ARPSrcIPMask  NWFilterField `xml:"arpsrcipmask,attr,omitempty"`
	ARPDstIPAddr  NWFilterField `xml:"arpdstipaddr,attr,omitempty"`
	ARPDstIPMask  NWFilterField `xml:"arpdstipmask,attr,omitempty"`
	Gratuitous    NWFilterField `xml:"gratuitous,attr,omitempty"`
	Comment       string        `xml:"comment,attr,omitempty"`
}

      type NWFilterRuleSCTP 

      type NWFilterRuleSCTP struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	NWFilterRuleCommonPort
	Comment string `xml:"comment,attr,omitempty"`
}

      type NWFilterRuleSCTPIPv6 

      type NWFilterRuleSCTPIPv6 struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP