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"`
      	ID         int                    `xml:"id,attr"`
      	None       *DomainAudioNone       `xml:"-"`
      	ALSA       *DomainAudioALSA       `xml:"-"`
      	CoreAudio  *DomainAudioCoreAudio  `xml:"-"`
      	Jack       *DomainAudioJack       `xml:"-"`
      	OSS        *DomainAudioOSS        `xml:"-"`
      	PulseAudio *DomainAudioPulseAudio `xml:"-"`
      	SDL        *DomainAudioSDL        `xml:"-"`
      	SPICE      *DomainAudioSPICE      `xml:"-"`
      	File       *DomainAudioFile       `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 DomainAudioALSA

      type DomainAudioALSA struct {
      	Input  *DomainAudioALSAChannel `xml:"input"`
      	Output *DomainAudioALSAChannel `xml:"output"`
      }

      type DomainAudioALSAChannel

      type DomainAudioALSAChannel struct {
      	DomainAudioChannel
      	Dev string `xml:"dev,attr,omitempty"`
      }

      type DomainAudioChannel

      type DomainAudioChannel struct {
      	MixingEngine  string                      `xml:"mixingEngine,attr,omitempty"`
      	FixedSettings string                      `xml:"fixedSettings,attr,omitempty"`
      	Voices        uint                        `xml:"voices,attr,omitempty"`
      	Settings      *DomainAudioChannelSettings `xml:"settings"`
      	BufferLength  uint                        `xml:"bufferLength,attr,omitempty"`
      }

      type DomainAudioChannelSettings

      type DomainAudioChannelSettings struct {
      	Frequency uint   `xml:"frequency,attr,omitempty"`
      	Channels  uint   `xml:"channels,attr,omitempty"`
      	Format    string `xml:"format,attr,omitempty"`
      }

      type DomainAudioCoreAudio

      type DomainAudioCoreAudio struct {
      	Input  *DomainAudioCoreAudioChannel `xml:"input"`
      	Output *DomainAudioCoreAudioChannel `xml:"output"`
      }

      type DomainAudioCoreAudioChannel

      type DomainAudioCoreAudioChannel struct {
      	DomainAudioChannel
      	BufferCount uint `xml:"bufferCount,attr,omitempty"`
      }

      type DomainAudioFile

      type DomainAudioFile struct {
      	Path   string                  `xml:"path,attr,omitempty"`
      	Input  *DomainAudioFileChannel `xml:"input"`
      	Output *DomainAudioFileChannel `xml:"output"`
      }

      type DomainAudioFileChannel

      type DomainAudioFileChannel struct {
      	DomainAudioChannel
      }

      type DomainAudioJack

      type DomainAudioJack struct {
      	Input  *DomainAudioJackChannel `xml:"input"`
      	Output *DomainAudioJackChannel `xml:"output"`
      }

      type DomainAudioJackChannel

      type DomainAudioJackChannel struct {
      	DomainAudioChannel
      	ServerName   string `xml:"serverName,attr,omitempty"`
      	ClientName   string `xml:"clientName,attr,omitempty"`
      	ConnectPorts string `xml:"connectPorts,attr,omitempty"`
      	ExactName    string `xml:"exactName,attr,omitempty"`
      }

      type DomainAudioNone

      type DomainAudioNone struct {
      	Input  *DomainAudioNoneChannel `xml:"input"`
      	Output *DomainAudioNoneChannel `xml:"output"`
      }

      type DomainAudioNoneChannel

      type DomainAudioNoneChannel struct {
      	DomainAudioChannel
      }

      type DomainAudioOSS

      type DomainAudioOSS struct {
      	TryMMap   string `xml:"tryMMap,attr,omitempty"`
      	Exclusive string `xml:"exclusive,attr,omitempty"`
      	DSPPolicy *int   `xml:"dspPolicy,attr"`
      
      	Input  *DomainAudioOSSChannel `xml:"input"`
      	Output *DomainAudioOSSChannel `xml:"output"`
      }

      type DomainAudioOSSChannel

      type DomainAudioOSSChannel struct {
      	DomainAudioChannel
      	Dev         string `xml:"dev,attr,omitempty"`
      	BufferCount uint   `xml:"bufferCount,attr,omitempty"`
      	TryPoll     string `xml:"tryPoll,attr,omitempty"`
      }

      type DomainAudioPulseAudio

      type DomainAudioPulseAudio struct {
      	ServerName string                        `xml:"serverName,attr,omitempty"`
      	Input      *DomainAudioPulseAudioChannel `xml:"input"`
      	Output     *DomainAudioPulseAudioChannel `xml:"output"`
      }

      type DomainAudioPulseAudioChannel

      type DomainAudioPulseAudioChannel struct {
      	DomainAudioChannel
      	Name       string `xml:"name,attr,omitempty"`
      	StreamName string `xml:"streamName,attr,omitempty"`
      	Latency    uint   `xml:"latency,attr,omitempty"`
      }

      type DomainAudioSDL

      type DomainAudioSDL struct {
      	Driver string                 `xml:"driver,attr,omitempty"`
      	Input  *DomainAudioSDLChannel `xml:"input"`
      	Output *DomainAudioSDLChannel `xml:"output"`
      }

      type DomainAudioSDLChannel

      type DomainAudioSDLChannel struct {
      	DomainAudioChannel
      	BufferCount uint `xml:"bufferCount,attr,omitempty"`
      }

      type DomainAudioSPICE

      type DomainAudioSPICE struct {
      	Input  *DomainAudioSPICEChannel `xml:"input"`
      	Output *DomainAudioSPICEChannel `xml:"output"`
      }

      type DomainAudioSPICEChannel

      type DomainAudioSPICEChannel struct {
      	DomainAudioChannel
      }

      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:"-"`
      	Audio       *DomainGraphicAudio       `xml:"audio"`
      }

      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 DomainGraphicAudio

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

      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"`
      	PowerControl  string                  `xml:"powerControl,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"`
      	FirmwareInfo *DomainOSFirmwareInfo `xml:"firmware"`
      	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 DomainOSFirmwareFeature

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

      type DomainOSFirmwareInfo

      type DomainOSFirmwareInfo struct {
      	Features []DomainOSFirmwareFeature `xml:"feature"`
      }

      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