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

      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 (*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 (*DomainInterfaceVirtualPortParams) UnmarshalXML

      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