introduce podman machine

podman machine allows podman to create, manage, and interact with a vm
running some form of linux (default is fcos).  podman is then configured
to be able to interact with the vm automatically.

while this is usable on linux, the real push is to get this working on
both current apple architectures in macos.

Ashley Cui contributed to this PR and was a great help.

[NO TESTS NEEDED]

Signed-off-by: baude <bbaude@redhat.com>

113 files changed, 30793 insertions, 149 deletions

diff --git a/cmd/podman/machine/config.go b/cmd/podman/machine/config.go
deleted file mode 100644
index 5fa6aa50d..000000000
--- a/cmd/podman/machine/config.go
+++ /dev/null
@@ -1,38 +0,0 @@
-package machine
-
-import "fmt"
-
-type CreateOptions struct {
-	CPUS       uint64
-	Memory     uint64
-	KernelPath string
-	Devices    []VMDevices
-}
-
-type VMDevices struct {
-	Path     string
-	ReadOnly bool
-}
-
-type VM interface {
-	Create(name string, opts CreateOptions) error
-	Start(name string) error
-	Stop(name string) error
-}
-
-type TestVM struct {
-}
-
-func (vm *TestVM) Create(name string, opts CreateOptions) error {
-	fmt.Printf("Created: %s\n", name)
-	return nil
-}
-
-func (vm *TestVM) Start(name string) error {
-	fmt.Printf("Started: %s\n", name)
-	return nil
-}
-func (vm *TestVM) Stop(name string) error {
-	fmt.Printf("Stopped: %s\n", name)
-	return nil
-}
diff --git a/cmd/podman/machine/create.go b/cmd/podman/machine/create.go
index 35f0677ad..04c5e9e65 100644
--- a/cmd/podman/machine/create.go
+++ b/cmd/podman/machine/create.go
@@ -1,12 +1,11 @@
 package machine
 
 import (
-	"fmt"
-	"strings"
-
 	"github.com/containers/common/pkg/completion"
 	"github.com/containers/podman/v3/cmd/podman/registry"
 	"github.com/containers/podman/v3/pkg/domain/entities"
+	"github.com/containers/podman/v3/pkg/machine"
+	"github.com/containers/podman/v3/pkg/machine/qemu"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 )
@@ -17,17 +16,19 @@ var (
 		Short:             "Create a vm",
 		Long:              "Create a virtual machine for Podman to run on. Virtual machines are used to run Podman on Macs. ",
 		RunE:              create,
-		Args:              cobra.ExactArgs(1),
+		Args:              cobra.NoArgs,
 		Example:           `podman machine create myvm`,
 		ValidArgsFunction: completion.AutocompleteNone,
 	}
 )
 
 type CreateCLIOptions struct {
-	CPUS       uint64
-	Memory     uint64
-	KernelPath string
-	Devices    []string
+	CPUS         uint64
+	Memory       uint64
+	Devices      []string
+	ImagePath    string
+	IgnitionPath string
+	Name         string
 }
 
 var (
@@ -45,7 +46,7 @@ func init() {
 	cpusFlagName := "cpus"
 	flags.Uint64Var(
 		&createOpts.CPUS,
-		cpusFlagName, 0,
+		cpusFlagName, 1,
 		"Number of CPUs. The default is 0.000 which means no limit",
 	)
 	_ = createCmd.RegisterFlagCompletionFunc(cpusFlagName, completion.AutocompleteNone)
@@ -53,80 +54,54 @@ func init() {
 	memoryFlagName := "memory"
 	flags.Uint64VarP(
 		&createOpts.Memory,
-		memoryFlagName, "m", 0,
+		memoryFlagName, "m", 2048,
 		"Memory (in MB)",
 	)
 	_ = createCmd.RegisterFlagCompletionFunc(memoryFlagName, completion.AutocompleteNone)
 
-	kernelPathFlagName := "kernel-path"
+	deviceFlagName := "name"
 	flags.StringVar(
-		&createOpts.KernelPath,
-		kernelPathFlagName, "",
-		"Kernel path",
-	)
-	_ = createCmd.RegisterFlagCompletionFunc(kernelPathFlagName, completion.AutocompleteNone)
-
-	deviceFlagName := "device"
-	flags.StringSliceVar(
-		&createOpts.Devices,
-		deviceFlagName, []string{},
-		"Add a device",
+		&createOpts.Name,
+		deviceFlagName, "",
+		"set vm name",
 	)
 	_ = createCmd.RegisterFlagCompletionFunc(deviceFlagName, completion.AutocompleteDefault)
+
+	ImagePathFlagName := "image-path"
+	flags.StringVar(&createOpts.ImagePath, ImagePathFlagName, "", "Path to qcow image")
+	_ = createCmd.RegisterFlagCompletionFunc(ImagePathFlagName, completion.AutocompleteDefault)
+
+	IgnitionPathFlagName := "ignition-path"
+	flags.StringVar(&createOpts.IgnitionPath, IgnitionPathFlagName, "", "Path to ignition file")
+	_ = createCmd.RegisterFlagCompletionFunc(IgnitionPathFlagName, completion.AutocompleteDefault)
 }
 
+// TODO should we allow for a users to append to the qemu cmdline?
 func create(cmd *cobra.Command, args []string) error {
-	vmOpts := CreateOptions{
-		CPUS:       createOpts.CPUS,
-		Memory:     createOpts.Memory,
-		KernelPath: createOpts.KernelPath,
+	// TODO add ability to create default, not name required
+	if len(createOpts.Name) < 1 {
+		return errors.New("required --name not provided")
 	}
-
-	if cmd.Flags().Changed("device") {
-		devices, err := cmd.Flags().GetStringSlice("device")
-		if err != nil {
-			return err
-		}
-		vmOpts.Devices, err = parseDevices(devices)
-		if err != nil {
-			return err
-		}
+	vmOpts := machine.CreateOptions{
+		CPUS:         createOpts.CPUS,
+		Memory:       createOpts.Memory,
+		IgnitionPath: createOpts.IgnitionPath,
+		ImagePath:    createOpts.ImagePath,
+		Name:         createOpts.Name,
 	}
-
-	test := new(TestVM)
-	test.Create(args[0], vmOpts)
-
-	return nil
-}
-
-func parseDevices(devices []string) ([]VMDevices, error) {
-	vmDevices := make([]VMDevices, 0, len(devices))
-
-	for _, dev := range devices {
-		split := strings.Split(dev, ":")
-
-		if len(split) == 1 {
-			vmDevices = append(vmDevices, VMDevices{
-				Path:     split[0],
-				ReadOnly: false,
-			})
-		} else if len(split) == 2 {
-			var readonly bool
-
-			switch split[1] {
-			case "ro", "readonly":
-				readonly = true
-			default:
-				return nil, errors.New(fmt.Sprintf("Invalid readonly value: %s", dev))
-			}
-
-			vmDevices = append(vmDevices, VMDevices{
-				Path:     split[0],
-				ReadOnly: readonly,
-			})
-		} else {
-			return nil, errors.New(fmt.Sprintf("Invalid device format: %s", dev))
-		}
+	var (
+		vm     machine.VM
+		vmType string
+		err    error
+	)
+	switch vmType {
+	case "foobar":
+		// do nothing
+	default: // qemu is the default
+		vm, err = qemu.NewMachine(vmOpts)
+	}
+	if err != nil {
+		return err
 	}
-	return vmDevices, nil
+	return vm.Create(vmOpts)
 }
diff --git a/cmd/podman/machine/destroy.go b/cmd/podman/machine/destroy.go
new file mode 100644
index 000000000..ab23d607d
--- /dev/null
+++ b/cmd/podman/machine/destroy.go
@@ -0,0 +1,91 @@
+package machine
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v3/cmd/podman/common"
+	"github.com/containers/podman/v3/cmd/podman/registry"
+	"github.com/containers/podman/v3/pkg/domain/entities"
+	"github.com/containers/podman/v3/pkg/machine"
+	"github.com/containers/podman/v3/pkg/machine/qemu"
+	"github.com/spf13/cobra"
+)
+
+var (
+	destroyCmd = &cobra.Command{
+		Use:               "destroy [options] NAME",
+		Short:             "Destroy an existing machine",
+		Long:              "Destroy an existing machine ",
+		RunE:              destroy,
+		Args:              cobra.ExactArgs(1),
+		Example:           `podman machine destroy myvm`,
+		ValidArgsFunction: completion.AutocompleteNone,
+	}
+)
+
+var (
+	destoryOptions machine.DestroyOptions
+)
+
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: destroyCmd,
+		Parent:  machineCmd,
+	})
+
+	flags := destroyCmd.Flags()
+	formatFlagName := "force"
+	flags.BoolVar(&destoryOptions.Force, formatFlagName, false, "Do not prompt before destroying")
+	_ = destroyCmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteJSONFormat)
+
+	keysFlagName := "save-keys"
+	flags.BoolVar(&destoryOptions.SaveKeys, keysFlagName, false, "Do not delete SSH keys")
+	_ = destroyCmd.RegisterFlagCompletionFunc(keysFlagName, common.AutocompleteJSONFormat)
+
+	ignitionFlagName := "save-ignition"
+	flags.BoolVar(&destoryOptions.SaveIgnition, ignitionFlagName, false, "Do not delete ignition file")
+	_ = destroyCmd.RegisterFlagCompletionFunc(ignitionFlagName, common.AutocompleteJSONFormat)
+
+	imageFlagName := "save-image"
+	flags.BoolVar(&destoryOptions.SaveImage, imageFlagName, false, "Do not delete the image file")
+	_ = destroyCmd.RegisterFlagCompletionFunc(imageFlagName, common.AutocompleteJSONFormat)
+}
+
+func destroy(cmd *cobra.Command, args []string) error {
+	var (
+		err    error
+		vm     machine.VM
+		vmType string
+	)
+	switch vmType {
+	default:
+		vm, err = qemu.LoadVMByName(args[0])
+	}
+	if err != nil {
+		return err
+	}
+	confirmationMessage, doIt, err := vm.Destroy(args[0], machine.DestroyOptions{})
+	if err != nil {
+		return err
+	}
+
+	if !destoryOptions.Force {
+		// Warn user
+		fmt.Println(confirmationMessage)
+		reader := bufio.NewReader(os.Stdin)
+		fmt.Print("Are you sure you want to continue? [y/N] ")
+		answer, err := reader.ReadString('\n')
+		if err != nil {
+			return err
+		}
+		if strings.ToLower(answer)[0] != 'y' {
+			return nil
+		}
+	}
+	return doIt()
+}
diff --git a/cmd/podman/machine/ssh.go b/cmd/podman/machine/ssh.go
new file mode 100644
index 000000000..a0656d17b
--- /dev/null
+++ b/cmd/podman/machine/ssh.go
@@ -0,0 +1,47 @@
+package machine
+
+import (
+	"github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v3/cmd/podman/registry"
+	"github.com/containers/podman/v3/pkg/domain/entities"
+	"github.com/containers/podman/v3/pkg/machine"
+	"github.com/containers/podman/v3/pkg/machine/qemu"
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+)
+
+var (
+	sshCmd = &cobra.Command{
+		Use:               "ssh NAME",
+		Short:             "SSH into a virtual machine",
+		Long:              "SSH into a podman-managed virtual machine ",
+		RunE:              ssh,
+		Args:              cobra.ExactArgs(1),
+		Example:           `podman machine ssh myvm`,
+		ValidArgsFunction: completion.AutocompleteNone,
+	}
+)
+
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: sshCmd,
+		Parent:  machineCmd,
+	})
+}
+
+func ssh(cmd *cobra.Command, args []string) error {
+	var (
+		err    error
+		vm     machine.VM
+		vmType string
+	)
+	switch vmType {
+	default:
+		vm, err = qemu.LoadVMByName(args[0])
+	}
+	if err != nil {
+		return errors.Wrapf(err, "vm %s not found", args[0])
+	}
+	return vm.SSH(args[0], machine.SSHOptions{})
+}
diff --git a/cmd/podman/machine/start.go b/cmd/podman/machine/start.go
index 118ce74c0..762639358 100644
--- a/cmd/podman/machine/start.go
+++ b/cmd/podman/machine/start.go
@@ -4,6 +4,8 @@ import (
 	"github.com/containers/common/pkg/completion"
 	"github.com/containers/podman/v3/cmd/podman/registry"
 	"github.com/containers/podman/v3/pkg/domain/entities"
+	"github.com/containers/podman/v3/pkg/machine"
+	"github.com/containers/podman/v3/pkg/machine/qemu"
 	"github.com/spf13/cobra"
 )
 
@@ -28,7 +30,17 @@ func init() {
 }
 
 func start(cmd *cobra.Command, args []string) error {
-	test := new(TestVM)
-	test.Start(args[0])
-	return nil
+	var (
+		err    error
+		vm     machine.VM
+		vmType string
+	)
+	switch vmType {
+	default:
+		vm, err = qemu.LoadVMByName(args[0])
+	}
+	if err != nil {
+		return err
+	}
+	return vm.Start(args[0], machine.StartOptions{})
 }
diff --git a/cmd/podman/machine/stop.go b/cmd/podman/machine/stop.go
index d04b3a447..b6585c296 100644
--- a/cmd/podman/machine/stop.go
+++ b/cmd/podman/machine/stop.go
@@ -4,6 +4,8 @@ import (
 	"github.com/containers/common/pkg/completion"
 	"github.com/containers/podman/v3/cmd/podman/registry"
 	"github.com/containers/podman/v3/pkg/domain/entities"
+	"github.com/containers/podman/v3/pkg/machine"
+	"github.com/containers/podman/v3/pkg/machine/qemu"
 	"github.com/spf13/cobra"
 )
 
@@ -27,8 +29,19 @@ func init() {
 	})
 }
 
+// TODO  Name shouldnt be required, need to create a default vm
 func stop(cmd *cobra.Command, args []string) error {
-	test := new(TestVM)
-	test.Stop(args[0])
-	return nil
+	var (
+		err    error
+		vm     machine.VM
+		vmType string
+	)
+	switch vmType {
+	default:
+		vm, err = qemu.LoadVMByName(args[0])
+	}
+	if err != nil {
+		return err
+	}
+	return vm.Stop(args[0], machine.StopOptions{})
 }
diff --git a/docs/source/machine.rst b/docs/source/machine.rst
index 5fdfef6b4..aefceb3a5 100644
--- a/docs/source/machine.rst
+++ b/docs/source/machine.rst
@@ -1,7 +1,9 @@
 Machine
 ======
-:doc:`create <markdown/podman-machine-create.1>` Create a new virtual machine
 
-:doc:`start <markdown/podman-machine-start.1>` Start a virtual machine
 
+:doc:`create <markdown/podman-machine-create.1>` Create a new virtual machine
+:doc:`destroy <markdown/podman-machine-destroy.1>` Destroy a virtual machine
+:doc:`ssh <markdown/podman-machine-ssh.1>` SSH into a virtual machine
+:doc:`start <markdown/podman-machine-start.1>` Start a virtual machine
 :doc:`stop <markdown/podman-machine-stop.1>` Stop a virtual machine
diff --git a/docs/source/markdown/podman-machine-create.1.md b/docs/source/markdown/podman-machine-create.1.md
index 8282e3d56..1e199bb77 100644
--- a/docs/source/markdown/podman-machine-create.1.md
+++ b/docs/source/markdown/podman-machine-create.1.md
@@ -22,20 +22,21 @@ tied to the Linux kernel.
 
 Number of CPUs.
 
-#### **--memory**, **-m**=*number*
+#### **--ignition-path**
 
-Memory (in MB).
+Fully qualified path of the ignition file
 
-#### **--kernel-path**=*path*
+#### **--image-path**
 
-Print usage statement.
+Fully qualified path of the uncompressed image file
 
-#### **--device**=_device_[**:**_permissions_]
+#### **--memory**, **-m**=*number*
+
+Memory (in MB).
 
-Add a device to the virtual machine. Optional *permissions* parameter
-can be used to specify device permissions. **ro** means the device is read-only.
+#### **--name**
 
-Example: **--device=/dev/xvdc:ro**.
+Name to assign to the VM
 
 #### **--help**
 
diff --git a/docs/source/markdown/podman-machine-destroy.1.md b/docs/source/markdown/podman-machine-destroy.1.md
new file mode 100644
index 000000000..7c5421418
--- /dev/null
+++ b/docs/source/markdown/podman-machine-destroy.1.md
@@ -0,0 +1,65 @@
+% podman-machine-destroy(1)
+
+## NAME
+podman\-machine\-destroy - Destroy a virtual machine
+
+## SYNOPSIS
+**podman machine destroy** [*options*] *name*
+
+## DESCRIPTION
+
+Destroy a virtual machine and its related files.  What is actually deleted
+depends on the virtual machine type.  For all virtual machines, the generated
+SSH keys and the podman system connection are deleted.  The ignition files
+generated for that VM are also destroyed as is its image file on the filesystem.
+
+Users get a display of what will be deleted and are required to confirm unless the option `--force`
+is used.
+
+
+## OPTIONS
+
+#### **--help**
+
+Print usage statement.
+
+#### **--force**
+
+Delete without confirmation
+
+#### **--save-ignition**
+
+Do not delete the generated ignition file
+
+#### **--save-image**
+
+Do not delete the VM image
+
+#### **--save-keys**
+
+Do not delete the SSH keys for the VM.  The system connection is always
+deleted.
+
+## EXAMPLES
+
+Destroy a VM named "test1"
+
+```
+$ podman machine destroy test1
+
+The following files will be deleted:
+
+/home/user/.ssh/test1
+/home/user/.ssh/test1.pub
+/home/user/.config/containers/podman/machine/qemu/test1.ign
+/home/user/.local/share/containers/podman/machine/qemu/test1_fedora-coreos-33.20210315.1.0-qemu.x86_64.qcow2
+/home/user/.config/containers/podman/machine/qemu/test1.json
+
+Are you sure you want to continue? [y/N] y
+```
+
+## SEE ALSO
+podman-machine (1)
+
+## HISTORY
+March 2021, Originally compiled by Ashley Cui <acui@redhat.com>
diff --git a/docs/source/markdown/podman-machine-ssh.1.md b/docs/source/markdown/podman-machine-ssh.1.md
new file mode 100644
index 000000000..c0679347e
--- /dev/null
+++ b/docs/source/markdown/podman-machine-ssh.1.md
@@ -0,0 +1,33 @@
+% podman-machine-ssh(1)
+
+## NAME
+podman\-machine\-ssh - SSH into a virtual machine
+
+## SYNOPSIS
+**podman machine ssh** *name*
+
+## DESCRIPTION
+
+SSH into a Podman-managed virtual machine.
+
+Podman on MacOS requires a virtual machine. This is because containers are Linux -
+containers do not run on any other OS because containers' core functionality are
+tied to the Linux kernel.
+
+## OPTIONS
+
+#### **--help**
+
+Print usage statement.
+
+## EXAMPLES
+
+```
+$ podman machine ssh myvm
+```
+
+## SEE ALSO
+podman-machine (1)
+
+## HISTORY
+March 2021, Originally compiled by Ashley Cui <acui@redhat.com>
diff --git a/docs/source/markdown/podman-machine.1.md b/docs/source/markdown/podman-machine.1.md
index 167a6a9e9..b31d8f788 100644
--- a/docs/source/markdown/podman-machine.1.md
+++ b/docs/source/markdown/podman-machine.1.md
@@ -14,6 +14,8 @@ podman\-machine - Manage Podman's virtual machine
 | Command | Man Page                                                | Description                   |
 | ------- | ------------------------------------------------------- | ----------------------------- |
 | create  | [podman-machine-create(1)](podman-machine-create.1.md)  | Create a new virtual machine  |
+| destroy | [podman-machine-destroy(1)](podman-machine-destroy.1.md)| Destroy a virtual machine     |
+| ssh     | [podman-machine-ssh.1.md(1)](podman-machine-ssh.1.md)   | SSH into a virtual machine    |
 | start   | [podman-machine-start(1)](podman-machine-start.1.md)    | Start a virtual machine       |
 | stop    | [podman-machine-stop(1)](podman-machine-stop.1.md)      | Stop a virtual machine        |
 
diff --git a/go.mod b/go.mod
index 1f94095a2..333b593f6 100644
--- a/go.mod
+++ b/go.mod
@@ -18,9 +18,11 @@ require (
 	github.com/containers/psgo v1.5.2
 	github.com/containers/storage v1.28.0
 	github.com/coreos/go-systemd/v22 v22.3.0
+	github.com/coreos/stream-metadata-go v0.0.0-20210225230131-70edb9eb47b3
 	github.com/cri-o/ocicni v0.2.1-0.20210301205850-541cf7c703cf
 	github.com/cyphar/filepath-securejoin v0.2.2
 	github.com/davecgh/go-spew v1.1.1
+	github.com/digitalocean/go-qemu v0.0.0-20210209191958-152a1535e49f
 	github.com/docker/distribution v2.7.1+incompatible
 	github.com/docker/docker v20.10.0-beta1.0.20201113105859-b6bfff2a628f+incompatible
 	github.com/docker/go-connections v0.4.0
@@ -38,7 +40,6 @@ require (
 	github.com/json-iterator/go v1.1.10
 	github.com/kr/text v0.2.0 // indirect
 	github.com/mattn/go-colorable v0.1.8 // indirect
-	github.com/mattn/go-runewidth v0.0.10 // indirect
 	github.com/moby/term v0.0.0-20201110203204-bea5bbe245bf
 	github.com/mrunalp/fileutils v0.5.0
 	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
@@ -52,7 +53,6 @@ require (
 	github.com/opencontainers/selinux v1.8.0
 	github.com/pkg/errors v0.9.1
 	github.com/pmezard/go-difflib v1.0.0
-	github.com/rivo/uniseg v0.2.0 // indirect
 	github.com/rootless-containers/rootlesskit v0.14.0
 	github.com/sirupsen/logrus v1.8.1
 	github.com/spf13/cobra v1.1.3
@@ -60,6 +60,7 @@ require (
 	github.com/stretchr/testify v1.7.0
 	github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635
 	github.com/uber/jaeger-client-go v2.25.0+incompatible
+	github.com/vbauerster/mpb/v6 v6.0.2
 	github.com/vishvananda/netlink v1.1.1-0.20201029203352-d40f9887b852
 	go.etcd.io/bbolt v1.3.5
 	golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad
diff --git a/go.sum b/go.sum
index 385047cc9..fa26133dc 100644
--- a/go.sum
+++ b/go.sum
@@ -68,6 +68,7 @@ github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d h1:licZJFw2RwpH
 github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d/go.mod h1:asat636LX7Bqt5lYEZ27JNDcqxfjdBQuJ/MM4CN/Lzo=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf h1:qet1QNfXsQxTZqLG4oE62mJzwPIB8+Tee4RNCL9ulrY=
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
 github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
 github.com/alexflint/go-filemutex v0.0.0-20171022225611-72bdc8eae2ae/go.mod h1:CgnQgUtFrFz9mxFNtED3jI5tLDjKlOM+oUF/sTk6ps0=
@@ -208,6 +209,7 @@ github.com/coreos/go-iptables v0.5.0 h1:mw6SAibtHKZcNzAsOxjoHIG0gy5YFHhypWSSNc6E
 github.com/coreos/go-iptables v0.5.0/go.mod h1:/mVI274lEDI2ns62jHCDnCyBF9Iwsmekav8Dbxlm1MU=
 github.com/coreos/go-oidc v2.1.0+incompatible/go.mod h1:CgnwVTmzoESiwO9qyAFEMiHoZ1nMCKZlZ9V6mm3/LKc=
 github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
+github.com/coreos/go-semver v0.3.0 h1:wkHLiw0WNATZnSG7epLsujiMCgPAc9xhjJ4tgnAxmfM=
 github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
 github.com/coreos/go-systemd v0.0.0-20161114122254-48702e0da86b/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
 github.com/coreos/go-systemd v0.0.0-20180511133405-39ca1b05acc7/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
@@ -218,7 +220,10 @@ github.com/coreos/go-systemd/v22 v22.1.0/go.mod h1:xO0FLkIi5MaZafQlIrOotqXZ90ih+
 github.com/coreos/go-systemd/v22 v22.3.0 h1:C8u/Ljj8G8O6rqWJh2J8cDyeEFBMWvXlvJ/ccMyzcqw=
 github.com/coreos/go-systemd/v22 v22.3.0/go.mod h1:xO0FLkIi5MaZafQlIrOotqXZ90ih+1atmu1JpKERPPk=
 github.com/coreos/pkg v0.0.0-20160727233714-3ac0863d7acf/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
+github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f h1:lBNOc5arjvs8E5mO2tbpBpLoyyu8B6e44T7hJy6potg=
 github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
+github.com/coreos/stream-metadata-go v0.0.0-20210225230131-70edb9eb47b3 h1:0JspqV66RwYqYfvi8lCUoL5zUZMh9uN4hx/J5+NRXIE=
+github.com/coreos/stream-metadata-go v0.0.0-20210225230131-70edb9eb47b3/go.mod h1:RTjQyHgO/G37oJ3qnqYK6Z4TPZ5EsaabOtfMjVXmgko=
 github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
 github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
 github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
@@ -240,6 +245,10 @@ github.com/denverdino/aliyungo v0.0.0-20190125010748-a747050bb1ba/go.mod h1:dV8l
 github.com/dgrijalva/jwt-go v0.0.0-20170104182250-a601269ab70c/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
+github.com/digitalocean/go-libvirt v0.0.0-20201209184759-e2a69bcd5bd1 h1:j6vGflaQ2T7yOWqVgPdiRF73j/U2Zmpbbzab8nyDCRQ=
+github.com/digitalocean/go-libvirt v0.0.0-20201209184759-e2a69bcd5bd1/go.mod h1:QS1XzqZLcDniNYrN7EZefq3wIyb/M2WmJbql4ZKoc1Q=
+github.com/digitalocean/go-qemu v0.0.0-20210209191958-152a1535e49f h1:N2HvbwONtcvzegFxOAgGt15JsajIk5QzY3j5X3VzFDI=
+github.com/digitalocean/go-qemu v0.0.0-20210209191958-152a1535e49f/go.mod h1:IetBE52JfFxK46p2n2Rqm+p5Gx1gpu2hRHsrbnPOWZQ=
 github.com/dnaeon/go-vcr v1.0.1/go.mod h1:aBB1+wY4s93YsC3HHjMBMrwTj2R9FHDzUr9KyGc8n1E=
 github.com/docker/distribution v0.0.0-20190905152932-14b96e55d84c/go.mod h1:0+TTO4EOBfRPhZXAeF1Vu+W3hHZ8eLp8PgKVZlcvtFY=
 github.com/docker/distribution v2.7.1-0.20190205005809-0d3efadf0154+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
@@ -281,6 +290,7 @@ github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1m
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/evanphx/json-patch v4.9.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
 github.com/fanliao/go-promise v0.0.0-20141029170127-1890db352a72/go.mod h1:PjfxuH4FZdUyfMdtBio2lsRr1AKEaVPwelzuHuh8Lqc=
+github.com/fatih/camelcase v1.0.0/go.mod h1:yN2Sb0lFhZJUdVvtELVWefmrXpuZESvPmqwoZc+/fpc=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/form3tech-oss/jwt-go v3.2.2+incompatible/go.mod h1:pbq4aXjuKjdthFRnoDwaVPLA+WlJuPGy+QneDUgJi2k=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
@@ -770,6 +780,8 @@ github.com/vbatts/tar-split v0.11.1 h1:0Odu65rhcZ3JZaPHxl7tCI3V/C/Q9Zf82UFravl02
 github.com/vbatts/tar-split v0.11.1/go.mod h1:LEuURwDEiWjRjwu46yU3KVGuUdVv/dcnpcEPSzR8z6g=
 github.com/vbauerster/mpb/v5 v5.4.0 h1:n8JPunifvQvh6P1D1HAl2Ur9YcmKT1tpoUuiea5mlmg=
 github.com/vbauerster/mpb/v5 v5.4.0/go.mod h1:fi4wVo7BVQ22QcvFObm+VwliQXlV1eBT8JDaKXR4JGI=
+github.com/vbauerster/mpb/v6 v6.0.2 h1:DWFnBOcgHi9GUNduC1MbQ936Z7B77wvOnZexP9Hjzcw=
+github.com/vbauerster/mpb/v6 v6.0.2/go.mod h1:JDNVbdx4oAMMxZNXodDH2DeDY5xBJC8bDGHNFZwRqQM=
 github.com/vishvananda/netlink v0.0.0-20181108222139-023a6dafdcdf/go.mod h1:+SR5DhBJrl6ZM7CoCKvpw5BKroDKQ+PJqOg65H/2ktk=
 github.com/vishvananda/netlink v1.1.0/go.mod h1:cTgwzPIzzgDAYoQrMm0EdrjRUBkTqKYppBueQtXaqoE=
 github.com/vishvananda/netlink v1.1.1-0.20201029203352-d40f9887b852 h1:cPXZWzzG0NllBLdjWoD1nDfaqu98YMv+OneaKc8sPOA=
@@ -791,6 +803,7 @@ github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17
 github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y=
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yvasiyarov/go-metrics v0.0.0-20140926110328-57bccd1ccd43/go.mod h1:aX5oPXxHm3bOH+xeAttToC8pqch2ScQN/JoXYupl6xs=
 github.com/yvasiyarov/gorelic v0.0.0-20141212073537-a9bba5b9ab50/go.mod h1:NUSPSUX/bi6SeDMUh6brw0nXpxHnc96TguQh0+r/ssA=
@@ -891,6 +904,7 @@ golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLL
 golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/net v0.0.0-20201006153459-a7d1128ccaa0/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20201010224723-4f7140c49acb/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
@@ -987,6 +1001,8 @@ golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20201202213521-69691e467435/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201218084310-7d0127a74742/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4 h1:myAQVi0cGEoqQVR5POX+8RR2mrocKqNN1hmeMqhX27k=
 golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005 h1:pDMpM2zh2MT0kHy037cKlSby2nEhD50SYqwQk76Nm40=
@@ -1044,6 +1060,8 @@ golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapK
 golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200711155855-7342f9734a7d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e h1:4nW4NLDYnU28ojHaHO8OVxFHk/aQ33U01a9cjED+pzE=
 golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a h1:CB3a9Nez8M13wwlr/E2YtwoU+qYHKfC+JrDa45RXXoQ=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
diff --git a/pkg/bindings/connection.go b/pkg/bindings/connection.go
index 21a8e7a8b..148b592e9 100644
--- a/pkg/bindings/connection.go
+++ b/pkg/bindings/connection.go
@@ -22,11 +22,21 @@ import (
 	"golang.org/x/crypto/ssh/agent"
 )
 
+/*
+	WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
+	WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
+
+	DO NOT MERGE WITHOUT REVERTING THE HACK BELOW
+
+	WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
+	WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
+*/
 var (
 	BasePath = &url.URL{
 		Scheme: "http",
 		Host:   "d",
-		Path:   "/v" + version.APIVersion[version.Libpod][version.CurrentAPI].String() + "/libpod",
+		//Path:   "/v" + version.APIVersion[version.Libpod][version.CurrentAPI].String() + "/libpod",
+		Path: "/v3.0.0/libpod",
 	}
 )
 
diff --git a/pkg/machine/config.go b/pkg/machine/config.go
new file mode 100644
index 000000000..5e90dae51
--- /dev/null
+++ b/pkg/machine/config.go
@@ -0,0 +1,132 @@
+package machine
+
+import (
+	"net"
+	"net/url"
+	"os"
+	"path/filepath"
+
+	"github.com/containers/storage/pkg/homedir"
+)
+
+type CreateOptions struct {
+	Name         string
+	CPUS         uint64
+	Memory       uint64
+	IgnitionPath string
+	ImagePath    string
+	Username     string
+	URI          url.URL
+	IsDefault    bool
+	//KernelPath string
+	//Devices    []VMDevices
+}
+
+type RemoteConnectionType string
+
+var (
+	SSHRemoteConnection     RemoteConnectionType = "ssh"
+	DefaultIgnitionUserName                      = "core"
+)
+
+type Download struct {
+	Arch                  string
+	Artifact              string
+	CompressionType       string
+	Format                string
+	ImageName             string `json:"image_name"`
+	LocalPath             string
+	LocalUncompressedFile string
+	Sha256sum             string
+	URL                   *url.URL
+	VMName                string
+}
+
+type SSHOptions struct{}
+type StartOptions struct{}
+
+type StopOptions struct{}
+
+type DestroyOptions struct {
+	Force        bool
+	SaveKeys     bool
+	SaveImage    bool
+	SaveIgnition bool
+}
+
+type VM interface {
+	Create(opts CreateOptions) error
+	Destroy(name string, opts DestroyOptions) (string, func() error, error)
+	SSH(name string, opts SSHOptions) error
+	Start(name string, opts StartOptions) error
+	Stop(name string, opts StopOptions) error
+}
+
+type DistributionDownload interface {
+	DownloadImage() error
+	Get() *Download
+}
+
+// TODO is this even needed?
+type TestVM struct{}
+
+func (vm *TestVM) Create(opts CreateOptions) error {
+	return nil
+}
+
+func (vm *TestVM) Start(name string, opts StartOptions) error {
+	return nil
+}
+func (vm *TestVM) Stop(name string, opts StopOptions) error {
+	return nil
+}
+
+func (rc RemoteConnectionType) MakeSSHURL(host, path, port, userName string) url.URL {
+	userInfo := url.User(userName)
+	uri := url.URL{
+		Scheme:      "ssh",
+		Opaque:      "",
+		User:        userInfo,
+		Host:        host,
+		Path:        path,
+		RawPath:     "",
+		ForceQuery:  false,
+		RawQuery:    "",
+		Fragment:    "",
+		RawFragment: "",
+	}
+	if len(port) > 0 {
+		uri.Host = net.JoinHostPort(uri.Hostname(), port)
+	}
+	return uri
+}
+
+// GetDataDir returns the filepath where vm images should
+// live for podman-machine
+func GetDataDir(vmType string) (string, error) {
+	data, err := homedir.GetDataHome()
+	if err != nil {
+		return "", err
+	}
+	dataDir := filepath.Join(data, "containers", "podman", "machine", vmType)
+	if _, err := os.Stat(dataDir); !os.IsNotExist(err) {
+		return dataDir, nil
+	}
+	mkdirErr := os.MkdirAll(dataDir, 0755)
+	return dataDir, mkdirErr
+}
+
+// GetConfigDir returns the filepath to where configuration
+// files for podman-machine should live
+func GetConfDir(vmType string) (string, error) {
+	conf, err := homedir.GetConfigHome()
+	if err != nil {
+		return "", err
+	}
+	confDir := filepath.Join(conf, "containers", "podman", "machine", vmType)
+	if _, err := os.Stat(confDir); !os.IsNotExist(err) {
+		return confDir, nil
+	}
+	mkdirErr := os.MkdirAll(confDir, 0755)
+	return confDir, mkdirErr
+}
diff --git a/pkg/machine/connection.go b/pkg/machine/connection.go
new file mode 100644
index 000000000..e3985d8ac
--- /dev/null
+++ b/pkg/machine/connection.go
@@ -0,0 +1,50 @@
+package machine
+
+import (
+	"fmt"
+
+	"github.com/containers/common/pkg/config"
+	"github.com/pkg/errors"
+)
+
+func AddConnection(uri fmt.Stringer, name, identity string, isDefault bool) error {
+	if len(identity) < 1 {
+		return errors.New("identity must be defined")
+	}
+	cfg, err := config.ReadCustomConfig()
+	if err != nil {
+		return err
+	}
+	if _, ok := cfg.Engine.ServiceDestinations[name]; ok {
+		return errors.New("cannot overwrite connection")
+	}
+	if isDefault {
+		cfg.Engine.ActiveService = name
+	}
+	dst := config.Destination{
+		URI: uri.String(),
+	}
+	dst.Identity = identity
+	if cfg.Engine.ServiceDestinations == nil {
+		cfg.Engine.ServiceDestinations = map[string]config.Destination{
+			name: dst,
+		}
+		cfg.Engine.ActiveService = name
+	} else {
+		cfg.Engine.ServiceDestinations[name] = dst
+	}
+	return cfg.Write()
+}
+
+func RemoveConnection(name string) error {
+	cfg, err := config.ReadCustomConfig()
+	if err != nil {
+		return err
+	}
+	if _, ok := cfg.Engine.ServiceDestinations[name]; ok {
+		delete(cfg.Engine.ServiceDestinations, name)
+	} else {
+		return errors.Errorf("unable to find connection named %q", name)
+	}
+	return cfg.Write()
+}
diff --git a/pkg/machine/fcos.go b/pkg/machine/fcos.go
new file mode 100644
index 000000000..8bbad458f
--- /dev/null
+++ b/pkg/machine/fcos.go
@@ -0,0 +1,162 @@
+package machine
+
+import (
+	"crypto/sha256"
+	"io"
+	"io/ioutil"
+	url2 "net/url"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"github.com/containers/storage/pkg/archive"
+
+	"github.com/sirupsen/logrus"
+
+	digest "github.com/opencontainers/go-digest"
+)
+
+// These should eventually be moved into machine/qemu as
+// they are specific to running qemu
+var (
+	artifact string = "qemu"
+	Format   string = "qcow2.xz"
+)
+
+type FcosDownload struct {
+	Download
+}
+
+func NewFcosDownloader(vmType, vmName string) (DistributionDownload, error) {
+	info, err := getFCOSDownload()
+	if err != nil {
+		return nil, err
+	}
+	urlSplit := strings.Split(info.Location, "/")
+	imageName := urlSplit[len(urlSplit)-1]
+	url, err := url2.Parse(info.Location)
+	if err != nil {
+		return nil, err
+	}
+
+	dataDir, err := GetDataDir(vmType)
+	if err != nil {
+		return nil, err
+	}
+
+	fcd := FcosDownload{
+		Download: Download{
+			Arch:      getFcosArch(),
+			Artifact:  artifact,
+			Format:    Format,
+			ImageName: imageName,
+			LocalPath: filepath.Join(dataDir, imageName),
+			Sha256sum: info.Sha256Sum,
+			URL:       url,
+			VMName:    vmName,
+		},
+	}
+	fcd.Download.LocalUncompressedFile = fcd.getLocalUncompressedName()
+	return fcd, nil
+}
+
+func (f FcosDownload) getLocalUncompressedName() string {
+	uncompressedFilename := filepath.Join(filepath.Dir(f.LocalPath), f.VMName+"_"+f.ImageName)
+	return strings.TrimSuffix(uncompressedFilename, ".xz")
+}
+
+func (f FcosDownload) DownloadImage() error {
+	// check if the latest image is already present
+	ok, err := UpdateAvailable(&f.Download)
+	if err != nil {
+		return err
+	}
+	if !ok {
+		if err := DownloadVMImage(f.URL, f.LocalPath); err != nil {
+			return err
+		}
+	}
+	uncompressedFileWriter, err := os.OpenFile(f.getLocalUncompressedName(), os.O_CREATE|os.O_RDWR, 0600)
+	if err != nil {
+		return err
+	}
+	sourceFile, err := ioutil.ReadFile(f.LocalPath)
+	if err != nil {
+		return err
+	}
+	compressionType := archive.DetectCompression(sourceFile)
+	f.CompressionType = compressionType.Extension()
+
+	switch f.CompressionType {
+	case "tar.xz":
+		return decompressXZ(f.LocalPath, uncompressedFileWriter)
+	default:
+		// File seems to be uncompressed, make a copy
+		if err := copyFile(f.LocalPath, uncompressedFileWriter); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func copyFile(src string, dest *os.File) error {
+	source, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err := source.Close(); err != nil {
+			logrus.Error(err)
+		}
+	}()
+	_, err = io.Copy(dest, source)
+	return err
+}
+
+func (f FcosDownload) Get() *Download {
+	return &f.Download
+}
+
+type fcosDownloadInfo struct {
+	CompressionType string
+	Location        string
+	Release         string
+	Sha256Sum       string
+}
+
+func UpdateAvailable(d *Download) (bool, error) {
+	//	 check the sha of the local image if it exists
+	//  get the sha of the remote image
+	// == dont bother to pull
+	files, err := ioutil.ReadDir(filepath.Dir(d.LocalPath))
+	if err != nil {
+		return false, err
+	}
+	for _, file := range files {
+		if filepath.Base(d.LocalPath) == file.Name() {
+			b, err := ioutil.ReadFile(d.LocalPath)
+			if err != nil {
+				return false, err
+			}
+			s := sha256.Sum256(b)
+			sum := digest.NewDigestFromBytes(digest.SHA256, s[:])
+			if sum.Encoded() == d.Sha256sum {
+				return true, nil
+			}
+		}
+	}
+	return false, nil
+}
+
+func getFcosArch() string {
+	var arch string
+	// TODO fill in more architectures
+	switch runtime.GOARCH {
+	case "arm64":
+		arch = "aarch64"
+	default:
+		arch = "x86_64"
+	}
+	return arch
+}
diff --git a/pkg/machine/fcos_amd64.go b/pkg/machine/fcos_amd64.go
new file mode 100644
index 000000000..36676405a
--- /dev/null
+++ b/pkg/machine/fcos_amd64.go
@@ -0,0 +1,68 @@
+package machine
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/coreos/stream-metadata-go/fedoracoreos"
+	"github.com/coreos/stream-metadata-go/stream"
+	"github.com/sirupsen/logrus"
+)
+
+// This should get Exported and stay put as it will apply to all fcos downloads
+// getFCOS parses fedoraCoreOS's stream and returns the image download URL and the release version
+func getFCOSDownload() (*fcosDownloadInfo, error) {
+	var (
+		fcosstable stream.Stream
+	)
+	streamurl := fedoracoreos.GetStreamURL(fedoracoreos.StreamNext)
+	resp, err := http.Get(streamurl.String())
+	if err != nil {
+		return nil, err
+	}
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		if err := resp.Body.Close(); err != nil {
+			logrus.Error(err)
+		}
+	}()
+
+	if err := json.Unmarshal(body, &fcosstable); err != nil {
+		return nil, err
+	}
+	arch, ok := fcosstable.Architectures[getFcosArch()]
+	if !ok {
+		return nil, fmt.Errorf("unable to pull VM image: no targetArch in stream")
+	}
+	artifacts := arch.Artifacts
+	if artifacts == nil {
+		return nil, fmt.Errorf("unable to pull VM image: no artifact in stream")
+	}
+	qemu, ok := artifacts[artifact]
+	if !ok {
+		return nil, fmt.Errorf("unable to pull VM image: no qemu artifact in stream")
+	}
+	formats := qemu.Formats
+	if formats == nil {
+		return nil, fmt.Errorf("unable to pull VM image: no formats in stream")
+	}
+	qcow, ok := formats[Format]
+	if !ok {
+		return nil, fmt.Errorf("unable to pull VM image: no qcow2.xz format in stream")
+	}
+	disk := qcow.Disk
+	if disk == nil {
+		return nil, fmt.Errorf("unable to pull VM image: no disk in stream")
+	}
+	return &fcosDownloadInfo{
+		Location:        disk.Location,
+		Release:         qemu.Release,
+		Sha256Sum:       disk.Sha256,
+		CompressionType: "xz",
+	}, nil
+}
diff --git a/pkg/machine/fcos_arm64.go b/pkg/machine/fcos_arm64.go
new file mode 100644
index 000000000..ab50ca874
--- /dev/null
+++ b/pkg/machine/fcos_arm64.go
@@ -0,0 +1,169 @@
+package machine
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/sirupsen/logrus"
+)
+
+const aarchBaseURL = "https://fedorapeople.org/groups/fcos-images/builds/latest/aarch64/"
+
+// Total hack until automation is possible.
+// We need a proper json file at least to automate
+func getFCOSDownload() (*fcosDownloadInfo, error) {
+
+	meta := Build{}
+	fmt.Println(aarchBaseURL + "meta.json")
+	resp, err := http.Get(aarchBaseURL + "meta.json")
+	if err != nil {
+		return nil, err
+	}
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		if err := resp.Body.Close(); err != nil {
+			logrus.Error(err)
+		}
+	}()
+	if err := json.Unmarshal(body, &meta); err != nil {
+		return nil, err
+	}
+	return &fcosDownloadInfo{
+		Location:  "https://fedorapeople.org/groups/fcos-images/builds/latest/aarch64/fedora-coreos-33.20210310.dev.0-qemu.aarch64.qcow2",
+		Release:   "",
+		Sha256Sum: meta.BuildArtifacts.Qemu.Sha256,
+	}, nil
+}
+
+/*
+	All of this can be nuked when fcos upstream generates a proper meta data file for aarch.
+*/
+type AliyunImage struct {
+	ImageID string `json:"id"`
+	Region  string `json:"name"`
+}
+
+type Amis struct {
+	Hvm      string `json:"hvm"`
+	Region   string `json:"name"`
+	Snapshot string `json:"snapshot"`
+}
+
+type Artifact struct {
+	Path               string  `json:"path"`
+	Sha256             string  `json:"sha256"`
+	SizeInBytes        float64 `json:"size,omitempty"`
+	UncompressedSha256 string  `json:"uncompressed-sha256,omitempty"`
+	UncompressedSize   int     `json:"uncompressed-size,omitempty"`
+}
+
+type Build struct {
+	AlibabaAliyunUploads      []AliyunImage         `json:"aliyun,omitempty"`
+	Amis                      []Amis                `json:"amis,omitempty"`
+	Architecture              string                `json:"coreos-assembler.basearch,omitempty"`
+	Azure                     *Cloudartifact        `json:"azure,omitempty"`
+	BuildArtifacts            *BuildArtifacts       `json:"images,omitempty"`
+	BuildID                   string                `json:"buildid"`
+	BuildRef                  string                `json:"ref,omitempty"`
+	BuildSummary              string                `json:"summary"`
+	BuildTimeStamp            string                `json:"coreos-assembler.build-timestamp,omitempty"`
+	BuildURL                  string                `json:"build-url,omitempty"`
+	ConfigGitRev              string                `json:"coreos-assembler.config-gitrev,omitempty"`
+	ContainerConfigGit        *Git                  `json:"coreos-assembler.container-config-git,omitempty"`
+	CoreOsSource              string                `json:"coreos-assembler.code-source,omitempty"`
+	CosaContainerImageGit     *Git                  `json:"coreos-assembler.container-image-git,omitempty"`
+	CosaDelayedMetaMerge      bool                  `json:"coreos-assembler.delayed-meta-merge,omitempty"`
+	CosaImageChecksum         string                `json:"coreos-assembler.image-config-checksum,omitempty"`
+	CosaImageVersion          int                   `json:"coreos-assembler.image-genver,omitempty"`
+	Extensions                *Extensions           `json:"extensions,omitempty"`
+	FedoraCoreOsParentCommit  string                `json:"fedora-coreos.parent-commit,omitempty"`
+	FedoraCoreOsParentVersion string                `json:"fedora-coreos.parent-version,omitempty"`
+	Gcp                       *Gcp                  `json:"gcp,omitempty"`
+	GitDirty                  string                `json:"coreos-assembler.config-dirty,omitempty"`
+	ImageInputChecksum        string                `json:"coreos-assembler.image-input-checksum,omitempty"`
+	InputHasOfTheRpmOstree    string                `json:"rpm-ostree-inputhash"`
+	MetaStamp                 float64               `json:"coreos-assembler.meta-stamp,omitempty"`
+	Name                      string                `json:"name"`
+	Oscontainer               *Image                `json:"oscontainer,omitempty"`
+	OstreeCommit              string                `json:"ostree-commit"`
+	OstreeContentBytesWritten int                   `json:"ostree-content-bytes-written,omitempty"`
+	OstreeContentChecksum     string                `json:"ostree-content-checksum"`
+	OstreeNCacheHits          int                   `json:"ostree-n-cache-hits,omitempty"`
+	OstreeNContentTotal       int                   `json:"ostree-n-content-total,omitempty"`
+	OstreeNContentWritten     int                   `json:"ostree-n-content-written,omitempty"`
+	OstreeNMetadataTotal      int                   `json:"ostree-n-metadata-total,omitempty"`
+	OstreeNMetadataWritten    int                   `json:"ostree-n-metadata-written,omitempty"`
+	OstreeTimestamp           string                `json:"ostree-timestamp"`
+	OstreeVersion             string                `json:"ostree-version"`
+	OverridesActive           bool                  `json:"coreos-assembler.overrides-active,omitempty"`
+	PkgdiffAgainstParent      PackageSetDifferences `json:"parent-pkgdiff,omitempty"`
+	PkgdiffBetweenBuilds      PackageSetDifferences `json:"pkgdiff,omitempty"`
+	ReleasePayload            *Image                `json:"release-payload,omitempty"`
+}
+
+type BuildArtifacts struct {
+	Aliyun        *Artifact `json:"aliyun,omitempty"`
+	Aws           *Artifact `json:"aws,omitempty"`
+	Azure         *Artifact `json:"azure,omitempty"`
+	AzureStack    *Artifact `json:"azurestack,omitempty"`
+	Dasd          *Artifact `json:"dasd,omitempty"`
+	DigitalOcean  *Artifact `json:"digitalocean,omitempty"`
+	Exoscale      *Artifact `json:"exoscale,omitempty"`
+	Gcp           *Artifact `json:"gcp,omitempty"`
+	IbmCloud      *Artifact `json:"ibmcloud,omitempty"`
+	Initramfs     *Artifact `json:"initramfs,omitempty"`
+	Iso           *Artifact `json:"iso,omitempty"`
+	Kernel        *Artifact `json:"kernel,omitempty"`
+	LiveInitramfs *Artifact `json:"live-initramfs,omitempty"`
+	LiveIso       *Artifact `json:"live-iso,omitempty"`
+	LiveKernel    *Artifact `json:"live-kernel,omitempty"`
+	LiveRootfs    *Artifact `json:"live-rootfs,omitempty"`
+	Metal         *Artifact `json:"metal,omitempty"`
+	Metal4KNative *Artifact `json:"metal4k,omitempty"`
+	OpenStack     *Artifact `json:"openstack,omitempty"`
+	Ostree        Artifact  `json:"ostree"`
+	Qemu          *Artifact `json:"qemu,omitempty"`
+	Vmware        *Artifact `json:"vmware,omitempty"`
+	Vultr         *Artifact `json:"vultr,omitempty"`
+}
+
+type Cloudartifact struct {
+	Image string `json:"image"`
+	URL   string `json:"url"`
+}
+
+type Extensions struct {
+	Manifest       map[string]interface{} `json:"manifest"`
+	Path           string                 `json:"path"`
+	RpmOstreeState string                 `json:"rpm-ostree-state"`
+	Sha256         string                 `json:"sha256"`
+}
+
+type Gcp struct {
+	ImageFamily  string `json:"family,omitempty"`
+	ImageName    string `json:"image"`
+	ImageProject string `json:"project,omitempty"`
+	URL          string `json:"url"`
+}
+
+type Git struct {
+	Branch string `json:"branch,omitempty"`
+	Commit string `json:"commit"`
+	Dirty  string `json:"dirty,omitempty"`
+	Origin string `json:"origin"`
+}
+
+type Image struct {
+	Comment string `json:"comment,omitempty"`
+	Digest  string `json:"digest"`
+	Image   string `json:"image"`
+}
+
+type Items interface{}
+
+type PackageSetDifferences []Items
diff --git a/pkg/machine/ignition.go b/pkg/machine/ignition.go
new file mode 100644
index 000000000..ff79d5afb
--- /dev/null
+++ b/pkg/machine/ignition.go
@@ -0,0 +1,151 @@
+package machine
+
+import (
+	"encoding/json"
+	"io/ioutil"
+)
+
+/*
+	If this file gets too nuts, we can perhaps use existing go code
+	to create ignition files.  At this point, the file is so simple
+	that I chose to use structs and not import any code as I was
+	concerned (unsubstantiated) about too much bloat coming in.
+
+	https://github.com/openshift/machine-config-operator/blob/master/pkg/server/server.go
+*/
+
+// Convenience function to convert int to ptr
+func intToPtr(i int) *int {
+	return &i
+}
+
+// Convenience function to convert string to ptr
+func strToPtr(s string) *string {
+	return &s
+}
+
+// Convenience function to convert bool to ptr
+func boolToPtr(b bool) *bool {
+	return &b
+}
+
+func getNodeUsr(usrName string) NodeUser {
+	return NodeUser{Name: &usrName}
+}
+
+func getNodeGrp(grpName string) NodeGroup {
+	return NodeGroup{Name: &grpName}
+}
+
+// NewIgnitionFile
+func NewIgnitionFile(name, key, writePath string) error {
+	if len(name) < 1 {
+		name = DefaultIgnitionUserName
+	}
+	ignVersion := Ignition{
+		Version: "3.2.0",
+	}
+
+	ignPassword := Passwd{
+		Users: []PasswdUser{{
+			Name:              name,
+			SSHAuthorizedKeys: []SSHAuthorizedKey{SSHAuthorizedKey(key)},
+		}},
+	}
+
+	ignStorage := Storage{
+		Directories: getDirs(name),
+		Files:       getFiles(name),
+		Links:       getLinks(name),
+	}
+	ignSystemd := Systemd{
+		Units: []Unit{
+			{
+				Enabled: boolToPtr(true),
+				Name:    "podman.socket",
+			}}}
+
+	ignConfig := Config{
+		Ignition: ignVersion,
+		Passwd:   ignPassword,
+		Storage:  ignStorage,
+		Systemd:  ignSystemd,
+	}
+	b, err := json.Marshal(ignConfig)
+	if err != nil {
+		return err
+	}
+	return ioutil.WriteFile(writePath, b, 0644)
+}
+
+func getDirs(usrName string) []Directory {
+	// Ignition has a bug/feature? where if you make a series of dirs
+	// in one swoop, then the leading dirs are creates as root.
+	newDirs := []string{
+		"/home/" + usrName + "/.config",
+		"/home/" + usrName + "/.config/systemd",
+		"/home/" + usrName + "/.config/systemd/user",
+		"/home/" + usrName + "/.config/systemd/user/default.target.wants",
+	}
+	var (
+		dirs = make([]Directory, len(newDirs))
+	)
+	for i, d := range newDirs {
+		newDir := Directory{
+			Node: Node{
+				Group: getNodeGrp(usrName),
+				Path:  d,
+				User:  getNodeUsr(usrName),
+			},
+			DirectoryEmbedded1: DirectoryEmbedded1{Mode: intToPtr(493)},
+		}
+		dirs[i] = newDir
+	}
+	return dirs
+}
+
+func getFiles(usrName string) []File {
+	var (
+		files []File
+	)
+	// Add a fake systemd service to get the user socket rolling
+	files = append(files, File{
+		Node: Node{
+			Group: getNodeGrp(usrName),
+			Path:  "/home/" + usrName + "/.config/systemd/user/linger-example.service",
+			User:  getNodeUsr(usrName),
+		},
+		FileEmbedded1: FileEmbedded1{
+			Append: nil,
+			Contents: Resource{
+				Source: strToPtr("data:,%5BUnit%5D%0ADescription%3DA%20systemd%20user%20unit%20demo%0AAfter%3Dnetwork-online.target%0AWants%3Dnetwork-online.target%20podman.socket%0A%5BService%5D%0AExecStart%3D%2Fusr%2Fbin%2Fsleep%20infinity%0A"),
+			},
+			Mode: intToPtr(484),
+		},
+	})
+
+	// Add a file into linger
+	files = append(files, File{
+		Node: Node{
+			Group: getNodeGrp(usrName),
+			Path:  "/var/lib/systemd/linger/core",
+			User:  getNodeUsr(usrName),
+		},
+		FileEmbedded1: FileEmbedded1{Mode: intToPtr(420)},
+	})
+	return files
+}
+
+func getLinks(usrName string) []Link {
+	return []Link{{
+		Node: Node{
+			Group: getNodeGrp(usrName),
+			Path:  "/home/" + usrName + "/.config/systemd/user/default.target.wants/linger-example.service",
+			User:  getNodeUsr(usrName),
+		},
+		LinkEmbedded1: LinkEmbedded1{
+			Hard:   boolToPtr(false),
+			Target: "/home/" + usrName + "/.config/systemd/user/linger-example.service",
+		},
+	}}
+}
diff --git a/pkg/machine/ignition_schema.go b/pkg/machine/ignition_schema.go
new file mode 100644
index 000000000..9dbd90ba4
--- /dev/null
+++ b/pkg/machine/ignition_schema.go
@@ -0,0 +1,251 @@
+package machine
+
+/*
+	This file was taken from https://github.com/coreos/ignition/blob/master/config/v3_2/types/schema.go in an effort to
+	use more of the core-os structs but not fully commit to bringing their api in.
+
+	// generated by "schematyper --package=types config/v3_2/schema/ignition.json -o config/v3_2/types/ignition_schema.go --root-type=Config" -- DO NOT EDIT
+*/
+
+type Clevis struct {
+	Custom    *Custom `json:"custom,omitempty"`
+	Tang      []Tang  `json:"tang,omitempty"`
+	Threshold *int    `json:"threshold,omitempty"`
+	Tpm2      *bool   `json:"tpm2,omitempty"`
+}
+
+type Config struct {
+	Ignition Ignition `json:"ignition"`
+	Passwd   Passwd   `json:"passwd,omitempty"`
+	Storage  Storage  `json:"storage,omitempty"`
+	Systemd  Systemd  `json:"systemd,omitempty"`
+}
+
+type Custom struct {
+	Config       string `json:"config"`
+	NeedsNetwork *bool  `json:"needsNetwork,omitempty"`
+	Pin          string `json:"pin"`
+}
+
+type Device string
+
+type Directory struct {
+	Node
+	DirectoryEmbedded1
+}
+
+type DirectoryEmbedded1 struct {
+	Mode *int `json:"mode,omitempty"`
+}
+
+type Disk struct {
+	Device     string      `json:"device"`
+	Partitions []Partition `json:"partitions,omitempty"`
+	WipeTable  *bool       `json:"wipeTable,omitempty"`
+}
+
+type Dropin struct {
+	Contents *string `json:"contents,omitempty"`
+	Name     string  `json:"name"`
+}
+
+type File struct {
+	Node
+	FileEmbedded1
+}
+
+type FileEmbedded1 struct {
+	Append   []Resource `json:"append,omitempty"`
+	Contents Resource   `json:"contents,omitempty"`
+	Mode     *int       `json:"mode,omitempty"`
+}
+
+type Filesystem struct {
+	Device         string             `json:"device"`
+	Format         *string            `json:"format,omitempty"`
+	Label          *string            `json:"label,omitempty"`
+	MountOptions   []MountOption      `json:"mountOptions,omitempty"`
+	Options        []FilesystemOption `json:"options,omitempty"`
+	Path           *string            `json:"path,omitempty"`
+	UUID           *string            `json:"uuid,omitempty"`
+	WipeFilesystem *bool              `json:"wipeFilesystem,omitempty"`
+}
+
+type FilesystemOption string
+
+type Group string
+
+type HTTPHeader struct {
+	Name  string  `json:"name"`
+	Value *string `json:"value,omitempty"`
+}
+
+type HTTPHeaders []HTTPHeader
+
+type Ignition struct {
+	Config   IgnitionConfig `json:"config,omitempty"`
+	Proxy    Proxy          `json:"proxy,omitempty"`
+	Security Security       `json:"security,omitempty"`
+	Timeouts Timeouts       `json:"timeouts,omitempty"`
+	Version  string         `json:"version,omitempty"`
+}
+
+type IgnitionConfig struct {
+	Merge   []Resource `json:"merge,omitempty"`
+	Replace Resource   `json:"replace,omitempty"`
+}
+
+type Link struct {
+	Node
+	LinkEmbedded1
+}
+
+type LinkEmbedded1 struct {
+	Hard   *bool  `json:"hard,omitempty"`
+	Target string `json:"target"`
+}
+
+type Luks struct {
+	Clevis     *Clevis      `json:"clevis,omitempty"`
+	Device     *string      `json:"device,omitempty"`
+	KeyFile    Resource     `json:"keyFile,omitempty"`
+	Label      *string      `json:"label,omitempty"`
+	Name       string       `json:"name"`
+	Options    []LuksOption `json:"options,omitempty"`
+	UUID       *string      `json:"uuid,omitempty"`
+	WipeVolume *bool        `json:"wipeVolume,omitempty"`
+}
+
+type LuksOption string
+
+type MountOption string
+
+type NoProxyItem string
+
+type Node struct {
+	Group     NodeGroup `json:"group,omitempty"`
+	Overwrite *bool     `json:"overwrite,omitempty"`
+	Path      string    `json:"path"`
+	User      NodeUser  `json:"user,omitempty"`
+}
+
+type NodeGroup struct {
+	ID   *int    `json:"id,omitempty"`
+	Name *string `json:"name,omitempty"`
+}
+
+type NodeUser struct {
+	ID   *int    `json:"id,omitempty"`
+	Name *string `json:"name,omitempty"`
+}
+
+type Partition struct {
+	GUID               *string `json:"guid,omitempty"`
+	Label              *string `json:"label,omitempty"`
+	Number             int     `json:"number,omitempty"`
+	Resize             *bool   `json:"resize,omitempty"`
+	ShouldExist        *bool   `json:"shouldExist,omitempty"`
+	SizeMiB            *int    `json:"sizeMiB,omitempty"`
+	StartMiB           *int    `json:"startMiB,omitempty"`
+	TypeGUID           *string `json:"typeGuid,omitempty"`
+	WipePartitionEntry *bool   `json:"wipePartitionEntry,omitempty"`
+}
+
+type Passwd struct {
+	Groups []PasswdGroup `json:"groups,omitempty"`
+	Users  []PasswdUser  `json:"users,omitempty"`
+}
+
+type PasswdGroup struct {
+	Gid          *int    `json:"gid,omitempty"`
+	Name         string  `json:"name"`
+	PasswordHash *string `json:"passwordHash,omitempty"`
+	ShouldExist  *bool   `json:"shouldExist,omitempty"`
+	System       *bool   `json:"system,omitempty"`
+}
+
+type PasswdUser struct {
+	Gecos             *string            `json:"gecos,omitempty"`
+	Groups            []Group            `json:"groups,omitempty"`
+	HomeDir           *string            `json:"homeDir,omitempty"`
+	Name              string             `json:"name"`
+	NoCreateHome      *bool              `json:"noCreateHome,omitempty"`
+	NoLogInit         *bool              `json:"noLogInit,omitempty"`
+	NoUserGroup       *bool              `json:"noUserGroup,omitempty"`
+	PasswordHash      *string            `json:"passwordHash,omitempty"`
+	PrimaryGroup      *string            `json:"primaryGroup,omitempty"`
+	SSHAuthorizedKeys []SSHAuthorizedKey `json:"sshAuthorizedKeys,omitempty"`
+	Shell             *string            `json:"shell,omitempty"`
+	ShouldExist       *bool              `json:"shouldExist,omitempty"`
+	System            *bool              `json:"system,omitempty"`
+	UID               *int               `json:"uid,omitempty"`
+}
+
+type Proxy struct {
+	HTTPProxy  *string       `json:"httpProxy,omitempty"`
+	HTTPSProxy *string       `json:"httpsProxy,omitempty"`
+	NoProxy    []NoProxyItem `json:"noProxy,omitempty"`
+}
+
+type Raid struct {
+	Devices []Device     `json:"devices"`
+	Level   string       `json:"level"`
+	Name    string       `json:"name"`
+	Options []RaidOption `json:"options,omitempty"`
+	Spares  *int         `json:"spares,omitempty"`
+}
+
+type RaidOption string
+
+type Resource struct {
+	Compression  *string      `json:"compression,omitempty"`
+	HTTPHeaders  HTTPHeaders  `json:"httpHeaders,omitempty"`
+	Source       *string      `json:"source,omitempty"`
+	Verification Verification `json:"verification,omitempty"`
+}
+
+type SSHAuthorizedKey string
+
+type Security struct {
+	TLS TLS `json:"tls,omitempty"`
+}
+
+type Storage struct {
+	Directories []Directory  `json:"directories,omitempty"`
+	Disks       []Disk       `json:"disks,omitempty"`
+	Files       []File       `json:"files,omitempty"`
+	Filesystems []Filesystem `json:"filesystems,omitempty"`
+	Links       []Link       `json:"links,omitempty"`
+	Luks        []Luks       `json:"luks,omitempty"`
+	Raid        []Raid       `json:"raid,omitempty"`
+}
+
+type Systemd struct {
+	Units []Unit `json:"units,omitempty"`
+}
+
+type TLS struct {
+	CertificateAuthorities []Resource `json:"certificateAuthorities,omitempty"`
+}
+
+type Tang struct {
+	Thumbprint *string `json:"thumbprint,omitempty"`
+	URL        string  `json:"url,omitempty"`
+}
+
+type Timeouts struct {
+	HTTPResponseHeaders *int `json:"httpResponseHeaders,omitempty"`
+	HTTPTotal           *int `json:"httpTotal,omitempty"`
+}
+
+type Unit struct {
+	Contents *string  `json:"contents,omitempty"`
+	Dropins  []Dropin `json:"dropins,omitempty"`
+	Enabled  *bool    `json:"enabled,omitempty"`
+	Mask     *bool    `json:"mask,omitempty"`
+	Name     string   `json:"name"`
+}
+
+type Verification struct {
+	Hash *string `json:"hash,omitempty"`
+}
diff --git a/pkg/machine/keys.go b/pkg/machine/keys.go
new file mode 100644
index 000000000..907e28f55
--- /dev/null
+++ b/pkg/machine/keys.go
@@ -0,0 +1,25 @@
+package machine
+
+import (
+	"io/ioutil"
+	"os/exec"
+	"strings"
+)
+
+// CreateSSHKeys makes a priv and pub ssh key for interacting
+// the a VM.
+func CreateSSHKeys(writeLocation string) (string, error) {
+	if err := generatekeys(writeLocation); err != nil {
+		return "", err
+	}
+	b, err := ioutil.ReadFile(writeLocation + ".pub")
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimSuffix(string(b), "\n"), nil
+}
+
+// generatekeys creates an ed25519 set of keys
+func generatekeys(writeLocation string) error {
+	return exec.Command("ssh-keygen", "-N", "", "-t", "ed25519", "-f", writeLocation).Run()
+}
diff --git a/pkg/machine/libvirt/config.go b/pkg/machine/libvirt/config.go
new file mode 100644
index 000000000..903f15fbc
--- /dev/null
+++ b/pkg/machine/libvirt/config.go
@@ -0,0 +1,4 @@
+package libvirt
+
+type MachineVM struct {
+}
diff --git a/pkg/machine/libvirt/machine.go b/pkg/machine/libvirt/machine.go
new file mode 100644
index 000000000..2c907ba5f
--- /dev/null
+++ b/pkg/machine/libvirt/machine.go
@@ -0,0 +1,15 @@
+package libvirt
+
+import "github.com/containers/podman/v3/pkg/machine"
+
+func (v *MachineVM) Create(name string, opts machine.CreateOptions) error {
+	return nil
+}
+
+func (v *MachineVM) Start(name string) error {
+	return nil
+}
+
+func (v *MachineVM) Stop(name string) error {
+	return nil
+}
diff --git a/pkg/machine/pull.go b/pkg/machine/pull.go
new file mode 100644
index 000000000..39dde15b8
--- /dev/null
+++ b/pkg/machine/pull.go
@@ -0,0 +1,97 @@
+package machine
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"strings"
+	"time"
+
+	"github.com/sirupsen/logrus"
+	"github.com/vbauerster/mpb/v6"
+	"github.com/vbauerster/mpb/v6/decor"
+)
+
+// DownloadVMImage downloads a VM image from url to given path
+// with download status
+func DownloadVMImage(downloadURL fmt.Stringer, localImagePath string) error {
+	out, err := os.Create(localImagePath)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err := out.Close(); err != nil {
+			logrus.Error(err)
+		}
+	}()
+
+	resp, err := http.Get(downloadURL.String())
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err := resp.Body.Close(); err != nil {
+			logrus.Error(err)
+		}
+	}()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("error downloading VM image: %s", resp.Status)
+	}
+	size := resp.ContentLength
+	urlSplit := strings.Split(downloadURL.String(), "/")
+	prefix := "Downloading VM image: " + urlSplit[len(urlSplit)-1]
+	onComplete := prefix + ": done"
+
+	p := mpb.New(
+		mpb.WithWidth(60),
+		mpb.WithRefreshRate(180*time.Millisecond),
+	)
+
+	bar := p.AddBar(size,
+		mpb.BarFillerClearOnComplete(),
+		mpb.PrependDecorators(
+			decor.OnComplete(decor.Name(prefix), onComplete),
+		),
+		mpb.AppendDecorators(
+			decor.OnComplete(decor.CountersKibiByte("%.1f / %.1f"), ""),
+		),
+	)
+
+	proxyReader := bar.ProxyReader(resp.Body)
+	defer func() {
+		if err := proxyReader.Close(); err != nil {
+			logrus.Error(err)
+		}
+	}()
+
+	if _, err := io.Copy(out, proxyReader); err != nil {
+		return err
+	}
+
+	p.Wait()
+	return nil
+}
+
+// Will error out if file without .xz already exists
+// Maybe extracting then renameing is a good idea here..
+// depends on xz: not pre-installed on mac, so it becomes a brew dependecy
+func decompressXZ(src string, output io.Writer) error {
+	fmt.Println("Extracting compressed file")
+	cmd := exec.Command("xzcat", "-k", src)
+	//cmd := exec.Command("xz", "-d", "-k", "-v", src)
+	stdOut, err := cmd.StdoutPipe()
+	if err != nil {
+		return err
+	}
+	//cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	go func() {
+		if _, err := io.Copy(output, stdOut); err != nil {
+			logrus.Error(err)
+		}
+	}()
+	return cmd.Run()
+}
diff --git a/pkg/machine/qemu/config.go b/pkg/machine/qemu/config.go
new file mode 100644
index 000000000..e4687914d
--- /dev/null
+++ b/pkg/machine/qemu/config.go
@@ -0,0 +1,43 @@
+package qemu
+
+import "time"
+
+type MachineVM struct {
+	// CPUs to be assigned to the VM
+	CPUs uint64
+	// The command line representation of the qemu command
+	CmdLine []string
+	// IdentityPath is the fq path to the ssh priv key
+	IdentityPath string
+	// IgnitionFilePath is the fq path to the .ign file
+	IgnitionFilePath string
+	// ImagePath is the fq path to
+	ImagePath string
+	// Memory in megabytes assigned to the vm
+	Memory uint64
+	// Name of the vm
+	Name string
+	// SSH port for user networking
+	Port int
+	// QMPMonitor is the qemu monitor object for sending commands
+	QMPMonitor Monitor
+	// RemoteUsername of the vm user
+	RemoteUsername string
+}
+
+type Monitor struct {
+	//	Address portion of the qmp monitor (/tmp/tmp.sock)
+	Address string
+	// Network portion of the qmp monitor (unix)
+	Network string
+	// Timeout in seconds for qmp monitor transactions
+	Timeout time.Duration
+}
+
+var (
+	// defaultQMPTimeout is the timeout duration for the
+	// qmp monitor interactions
+	defaultQMPTimeout time.Duration = 2 * time.Second
+	// defaultRemoteUser describes the ssh username default
+	defaultRemoteUser = "core"
+)
diff --git a/pkg/machine/qemu/machine.go b/pkg/machine/qemu/machine.go
new file mode 100644
index 000000000..92a16dda7
--- /dev/null
+++ b/pkg/machine/qemu/machine.go
@@ -0,0 +1,304 @@
+package qemu
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"time"
+
+	"github.com/containers/podman/v3/pkg/machine"
+	"github.com/containers/podman/v3/pkg/specgen"
+	"github.com/containers/storage/pkg/homedir"
+	"github.com/digitalocean/go-qemu/qmp"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+)
+
+var (
+	// vmtype refers to qemu (vs libvirt, krun, etc)
+	vmtype = "qemu"
+	// qemuCommon are the common command line arguments between the arches
+	//qemuCommon = []string{"-cpu", "host", "-qmp", "unix://tmp/qmp.sock,server,nowait"}
+	//qemuCommon  = []string{"-cpu", "host", "-qmp", "tcp:localhost:4444,server,nowait"}
+)
+
+// NewMachine creates an instance of a virtual machine based on the qemu
+// virtualization.
+func NewMachine(opts machine.CreateOptions) (machine.VM, error) {
+	vmConfigDir, err := machine.GetConfDir(vmtype)
+	if err != nil {
+		return nil, err
+	}
+	vm := new(MachineVM)
+	if len(opts.Name) > 0 {
+		vm.Name = opts.Name
+	}
+	vm.IgnitionFilePath = opts.IgnitionPath
+	// If no ignitionfilepath was provided, use defaults
+	if len(vm.IgnitionFilePath) < 1 {
+		ignitionFile := filepath.Join(vmConfigDir, vm.Name+".ign")
+		vm.IgnitionFilePath = ignitionFile
+	}
+
+	// An image was specified
+	if len(opts.ImagePath) > 0 {
+		vm.ImagePath = opts.ImagePath
+	}
+
+	// Assign remote user name. if not provided, use default
+	vm.RemoteUsername = opts.Username
+	if len(vm.RemoteUsername) < 1 {
+		vm.RemoteUsername = defaultRemoteUser
+	}
+
+	// Add a random port for ssh
+	port, err := specgen.GetRandomPort()
+	if err != nil {
+		return nil, err
+	}
+	vm.Port = port
+
+	vm.CPUs = opts.CPUS
+	vm.Memory = opts.Memory
+
+	// Look up the executable
+	execPath, err := exec.LookPath(QemuCommand)
+	if err != nil {
+		return nil, err
+	}
+	cmd := append([]string{execPath})
+	// Add memory
+	cmd = append(cmd, []string{"-m", strconv.Itoa(int(vm.Memory))}...)
+	// Add cpus
+	// TODO
+	// Add ignition file
+	cmd = append(cmd, []string{"-fw_cfg", "name=opt/com.coreos/config,file=" + vm.IgnitionFilePath}...)
+	// Add qmp socket
+	monitor, err := NewQMPMonitor("unix", vm.Name, defaultQMPTimeout)
+	if err != nil {
+		return nil, err
+	}
+	vm.QMPMonitor = monitor
+	cmd = append(cmd, []string{"-qmp", monitor.Network + ":/" + monitor.Address + ",server,nowait"}...)
+
+	// Add network
+	cmd = append(cmd, "-nic", "user,model=virtio,hostfwd=tcp::"+strconv.Itoa(vm.Port)+"-:22")
+	vm.CmdLine = cmd
+	fmt.Println("///")
+	return vm, nil
+}
+
+// LoadByName reads a json file that describes a known qemu vm
+// and returns a vm instance
+func LoadVMByName(name string) (machine.VM, error) {
+	// TODO need to define an error relating to ErrMachineNotFound
+	vm := new(MachineVM)
+	vmConfigDir, err := machine.GetConfDir(vmtype)
+	if err != nil {
+		return nil, err
+	}
+	b, err := ioutil.ReadFile(filepath.Join(vmConfigDir, name+".json"))
+	if err != nil {
+		return nil, err
+	}
+	err = json.Unmarshal(b, vm)
+	logrus.Debug(vm.CmdLine)
+	return vm, err
+}
+
+// Create writes the json configuration file to the filesystem for
+// other verbs (start, stop)
+func (v *MachineVM) Create(opts machine.CreateOptions) error {
+	sshDir := filepath.Join(homedir.Get(), ".ssh")
+	// GetConfDir creates the directory so no need to check for
+	// its existence
+	vmConfigDir, err := machine.GetConfDir(vmtype)
+	if err != nil {
+		return err
+	}
+	jsonFile := filepath.Join(vmConfigDir, v.Name) + ".json"
+	v.IdentityPath = filepath.Join(sshDir, v.Name)
+
+	dd, err := machine.NewFcosDownloader(vmtype, v.Name)
+	if err != nil {
+		return err
+	}
+
+	v.ImagePath = dd.Get().LocalUncompressedFile
+	if err := dd.DownloadImage(); err != nil {
+		return err
+	}
+	// Add arch specific options including image location
+	v.CmdLine = append(v.CmdLine, v.addArchOptions()...)
+
+	// Add location of bootable image
+	v.CmdLine = append(v.CmdLine, "-drive", "if=virtio,file="+v.ImagePath)
+	// This kind of stinks but no other way around this r/n
+	uri := machine.SSHRemoteConnection.MakeSSHURL("localhost", "/run/user/1000/podman/podman.sock", strconv.Itoa(v.Port), v.RemoteUsername)
+	if err := machine.AddConnection(&uri, v.Name, filepath.Join(sshDir, v.Name), opts.IsDefault); err != nil {
+		return err
+	}
+	// Write the JSON file
+	b, err := json.MarshalIndent(v, "", " ")
+	if err != nil {
+		return err
+	}
+	if err := ioutil.WriteFile(jsonFile, b, 0644); err != nil {
+		return err
+	}
+	key, err := machine.CreateSSHKeys(v.IdentityPath)
+	if err != nil {
+		return err
+	}
+	// Run arch specific things that need to be done
+	if err := v.prepare(); err != nil {
+		return err
+	}
+	// Write the ignition file
+	return machine.NewIgnitionFile(opts.Username, key, v.IgnitionFilePath)
+}
+
+// Start executes the qemu command line and forks it
+func (v *MachineVM) Start(name string, _ machine.StartOptions) error {
+	var (
+		err error
+	)
+	attr := new(os.ProcAttr)
+	files := []*os.File{os.Stdin, os.Stdout, os.Stderr}
+	attr.Files = files
+	fmt.Print(v.CmdLine)
+	_, err = os.StartProcess(v.CmdLine[0], v.CmdLine, attr)
+	return err
+}
+
+// Stop uses the qmp monitor to call a system_powerdown
+func (v *MachineVM) Stop(name string, _ machine.StopOptions) error {
+	// check if the qmp socket is there. if not, qemu instance is gone
+	if _, err := os.Stat(v.QMPMonitor.Address); os.IsNotExist(err) {
+		// Right now it is NOT an error to stop a stopped machine
+		logrus.Debugf("QMP monitor socket %v does not exist", v.QMPMonitor.Address)
+		return nil
+	}
+	qmpMonitor, err := qmp.NewSocketMonitor(v.QMPMonitor.Network, v.QMPMonitor.Address, v.QMPMonitor.Timeout)
+	if err != nil {
+		return err
+	}
+	// Simple JSON formation for the QAPI
+	stopCommand := struct {
+		Execute string `json:"execute"`
+	}{
+		Execute: "system_powerdown",
+	}
+	input, err := json.Marshal(stopCommand)
+	if err != nil {
+		return err
+	}
+	if err := qmpMonitor.Connect(); err != nil {
+		return err
+	}
+	defer func() {
+		if err := qmpMonitor.Disconnect(); err != nil {
+			logrus.Error(err)
+		}
+	}()
+	_, err = qmpMonitor.Run(input)
+	return err
+}
+
+// NewQMPMonitor creates the monitor subsection of our vm
+func NewQMPMonitor(network, name string, timeout time.Duration) (Monitor, error) {
+	rtDir, err := getDataDir()
+	if err != nil {
+		return Monitor{}, err
+	}
+	if timeout == 0 {
+		timeout = defaultQMPTimeout
+	}
+	monitor := Monitor{
+		Network: network,
+		Address: filepath.Join(rtDir, "podman", "qmp_"+name+".sock"),
+		Timeout: timeout,
+	}
+	return monitor, nil
+}
+
+func (v *MachineVM) Destroy(name string, opts machine.DestroyOptions) (string, func() error, error) {
+	var (
+		files []string
+	)
+
+	// cannot remove a running vm
+	if v.isRunning() {
+		return "", nil, errors.Errorf("running vm %q cannot be destroyed", v.Name)
+	}
+
+	// Collect all the files that need to be destroyed
+	if !opts.SaveKeys {
+		files = append(files, v.IdentityPath, v.IdentityPath+".pub")
+	}
+	if !opts.SaveIgnition {
+		files = append(files, v.IgnitionFilePath)
+	}
+	if !opts.SaveImage {
+		files = append(files, v.ImagePath)
+	}
+	files = append(files, v.archRemovalFiles()...)
+
+	if err := machine.RemoveConnection(v.Name); err != nil {
+		logrus.Error(err)
+	}
+	vmConfigDir, err := machine.GetConfDir(vmtype)
+	if err != nil {
+		return "", nil, err
+	}
+	files = append(files, filepath.Join(vmConfigDir, v.Name+".json"))
+	confirmationMessage := "\nThe following files will be deleted:\n\n"
+	for _, msg := range files {
+		confirmationMessage += msg + "\n"
+	}
+	confirmationMessage += "\n"
+	return confirmationMessage, func() error {
+		for _, f := range files {
+			if err := os.Remove(f); err != nil {
+				logrus.Error(err)
+			}
+		}
+		return nil
+	}, nil
+}
+
+func (v *MachineVM) isRunning() bool {
+	// Check if qmp socket path exists
+	if _, err := os.Stat(v.QMPMonitor.Address); os.IsNotExist(err) {
+		return false
+	}
+	// Check if we can dial it
+	if _, err := qmp.NewSocketMonitor(v.QMPMonitor.Network, v.QMPMonitor.Address, v.QMPMonitor.Timeout); err != nil {
+		return false
+	}
+	return true
+}
+
+// SSH opens an interactive SSH session to the vm specified.
+// Added ssh function to VM interface: pkg/machine/config/go : line 58
+func (v *MachineVM) SSH(name string, opts machine.SSHOptions) error {
+	if !v.isRunning() {
+		return errors.Errorf("vm %q is not running.", v.Name)
+	}
+
+	sshDestination := v.RemoteUsername + "@localhost"
+	port := strconv.Itoa(v.Port)
+
+	fmt.Printf("Connecting to vm %s. To close connection, use `~.` or `exit`\n", v.Name)
+
+	cmd := exec.Command("ssh", "-i", v.IdentityPath, "-p", port, sshDestination)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Stdin = os.Stdin
+
+	return cmd.Run()
+}
diff --git a/pkg/machine/qemu/options_amd64.go b/pkg/machine/qemu/options_amd64.go
new file mode 100644
index 000000000..85a2c4b3e
--- /dev/null
+++ b/pkg/machine/qemu/options_amd64.go
@@ -0,0 +1,26 @@
+package qemu
+
+import (
+	"github.com/containers/podman/v3/pkg/util"
+)
+
+var (
+	QemuCommand = "qemu-kvm"
+)
+
+func (v *MachineVM) addArchOptions() []string {
+	opts := []string{"-cpu", "host"}
+	return opts
+}
+
+func (v *MachineVM) prepare() error {
+	return nil
+}
+
+func (v *MachineVM) archRemovalFiles() []string {
+	return []string{}
+}
+
+func getDataDir() (string, error) {
+	return util.GetRuntimeDir()
+}
diff --git a/pkg/machine/qemu/options_arm64.go b/pkg/machine/qemu/options_arm64.go
new file mode 100644
index 000000000..c5b0ea16b
--- /dev/null
+++ b/pkg/machine/qemu/options_arm64.go
@@ -0,0 +1,40 @@
+package qemu
+
+import (
+	"os/exec"
+	"path/filepath"
+)
+
+var (
+	QemuCommand = "qemu-system-aarch64"
+)
+
+func (v *MachineVM) addArchOptions() []string {
+	ovmfDir := getOvmfDir(v.ImagePath, v.Name)
+	opts := []string{
+		"-accel", "hvf",
+		"-cpu", "cortex-a57",
+		"-M", "virt,highmem=off",
+		"-drive", "file=/usr/local/share/qemu/edk2-aarch64-code.fd,if=pflash,format=raw,readonly=on",
+		"-drive", "file=" + ovmfDir + ",if=pflash,format=raw"}
+	return opts
+}
+
+func (v *MachineVM) prepare() error {
+	ovmfDir := getOvmfDir(v.ImagePath, v.Name)
+	cmd := []string{"dd", "if=/dev/zero", "conv=sync", "bs=1m", "count=64", "of=" + ovmfDir}
+	return exec.Command(cmd[0], cmd[1:]...).Run()
+}
+
+func (v *MachineVM) archRemovalFiles() []string {
+	ovmDir := getOvmfDir(v.ImagePath, v.Name)
+	return []string{ovmDir}
+}
+
+func getDataDir() (string, error) {
+	return "/tmp", nil
+}
+
+func getOvmfDir(imagePath, vmName string) string {
+	return filepath.Join(filepath.Dir(imagePath), vmName+"_ovmf_vars.fd")
+}
diff --git a/pkg/specgen/generate/ports.go b/pkg/specgen/generate/ports.go
index 6cf83ed81..d5d779c8f 100644
--- a/pkg/specgen/generate/ports.go
+++ b/pkg/specgen/generate/ports.go
@@ -218,7 +218,7 @@ func parsePortMapping(portMappings []specgen.PortMapping) ([]ocicni.PortMapping,
 				// Only get a random candidate for single entries or the start
 				// of a range. Otherwise we just increment the candidate.
 				if !tmp.isInRange || tmp.startOfRange {
-					candidate, err = getRandomPort()
+					candidate, err = specgen.GetRandomPort()
 					if err != nil {
 						return nil, nil, nil, errors.Wrapf(err, "error getting candidate host port for container port %d", p.ContainerPort)
 					}
@@ -344,7 +344,7 @@ func createPortMappings(ctx context.Context, s *specgen.SpecGenerator, img *imag
 			for hostPort == 0 && tries > 0 {
 				// We can't select a specific protocol, which is
 				// unfortunate for the UDP case.
-				candidate, err := getRandomPort()
+				candidate, err := specgen.GetRandomPort()
 				if err != nil {
 					return nil, err
 				}
@@ -419,21 +419,3 @@ func checkProtocol(protocol string, allowSCTP bool) ([]string, error) {
 
 	return finalProto, nil
 }
-
-// Find a random, open port on the host
-func getRandomPort() (int, error) {
-	l, err := net.Listen("tcp", ":0")
-	if err != nil {
-		return 0, errors.Wrapf(err, "unable to get free TCP port")
-	}
-	defer l.Close()
-	_, randomPort, err := net.SplitHostPort(l.Addr().String())
-	if err != nil {
-		return 0, errors.Wrapf(err, "unable to determine free port")
-	}
-	rp, err := strconv.Atoi(randomPort)
-	if err != nil {
-		return 0, errors.Wrapf(err, "unable to convert random port to int")
-	}
-	return rp, nil
-}
diff --git a/pkg/specgen/ports.go b/pkg/specgen/ports.go
new file mode 100644
index 000000000..940b2a564
--- /dev/null
+++ b/pkg/specgen/ports.go
@@ -0,0 +1,26 @@
+package specgen
+
+import (
+	"net"
+	"strconv"
+
+	"github.com/pkg/errors"
+)
+
+// Find a random, open port on the host
+func GetRandomPort() (int, error) {
+	l, err := net.Listen("tcp", ":0")
+	if err != nil {
+		return 0, errors.Wrapf(err, "unable to get free TCP port")
+	}
+	defer l.Close()
+	_, randomPort, err := net.SplitHostPort(l.Addr().String())
+	if err != nil {
+		return 0, errors.Wrapf(err, "unable to determine free port")
+	}
+	rp, err := strconv.Atoi(randomPort)
+	if err != nil {
+		return 0, errors.Wrapf(err, "unable to convert random port to int")
+	}
+	return rp, nil
+}
diff --git a/vendor/github.com/coreos/stream-metadata-go/LICENSE b/vendor/github.com/coreos/stream-metadata-go/LICENSE
new file mode 100644
index 000000000..261eeb9e9
--- /dev/null
+++ b/vendor/github.com/coreos/stream-metadata-go/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/vendor/github.com/coreos/stream-metadata-go/fedoracoreos/fcos.go b/vendor/github.com/coreos/stream-metadata-go/fedoracoreos/fcos.go
new file mode 100644
index 000000000..9ffc7f7d1
--- /dev/null
+++ b/vendor/github.com/coreos/stream-metadata-go/fedoracoreos/fcos.go
@@ -0,0 +1,27 @@
+// Package fedoracoreos contains APIs defining well-known
+// streams for Fedora CoreOS and a method to retrieve
+// the URL for a stream endpoint.
+package fedoracoreos
+
+import (
+	"fmt"
+	"net/url"
+
+	"github.com/coreos/stream-metadata-go/fedoracoreos/internals"
+)
+
+const (
+	// StreamStable is the default stream
+	StreamStable = "stable"
+	// StreamTesting is what is intended to land in stable
+	StreamTesting = "testing"
+	// StreamNext usually tracks the next Fedora major version
+	StreamNext = "next"
+)
+
+// GetStreamURL returns the URL for the given stream
+func GetStreamURL(stream string) url.URL {
+	u := internals.GetBaseURL()
+	u.Path = fmt.Sprintf("streams/%s.json", stream)
+	return u
+}
diff --git a/vendor/github.com/coreos/stream-metadata-go/fedoracoreos/internals/fcosinternals.go b/vendor/github.com/coreos/stream-metadata-go/fedoracoreos/internals/fcosinternals.go
new file mode 100644
index 000000000..48b6addbc
--- /dev/null
+++ b/vendor/github.com/coreos/stream-metadata-go/fedoracoreos/internals/fcosinternals.go
@@ -0,0 +1,33 @@
+// Package internals contains functions for accessing
+// the underlying "releases" and coreos-assembler builds
+// backing streams.  General user code should avoid
+// this package and use streams.
+package internals
+
+import (
+	"fmt"
+	"net/url"
+)
+
+// GetBaseURL returns the base URL
+func GetBaseURL() url.URL {
+	return url.URL{
+		Scheme: "https",
+		Host:   "builds.coreos.fedoraproject.org",
+	}
+}
+
+// GetReleaseIndexURL returns the URL for the release index of a given stream.
+// Avoid this unless you have a specific need to test a specific release.
+func GetReleaseIndexURL(stream string) url.URL {
+	u := GetBaseURL()
+	u.Path = fmt.Sprintf("prod/streams/%s/releases.json", stream)
+	return u
+}
+
+// GetCosaBuild returns the coreos-assembler build URL
+func GetCosaBuild(stream, buildID, arch string) url.URL {
+	u := GetBaseURL()
+	u.Path = fmt.Sprintf("prod/streams/%s/builds/%s/%s/", stream, buildID, arch)
+	return u
+}
diff --git a/vendor/github.com/coreos/stream-metadata-go/stream/rhcos/rhcos.go b/vendor/github.com/coreos/stream-metadata-go/stream/rhcos/rhcos.go
new file mode 100644
index 000000000..320d84b41
--- /dev/null
+++ b/vendor/github.com/coreos/stream-metadata-go/stream/rhcos/rhcos.go
@@ -0,0 +1,18 @@
+package rhcos
+
+// Extensions is data specific to Red Hat Enterprise Linux CoreOS
+type Extensions struct {
+	AzureDisk *AzureDisk `json:"azure-disk,omitempty"`
+}
+
+// AzureDisk represents an Azure disk image that can be imported
+// into an image gallery or otherwise replicated, and then used
+// as a boot source for virtual machines.
+type AzureDisk struct {
+	// Release is the source release version
+	Release string `json:"release"`
+	// URL to an image already stored in Azure infrastructure
+	// that can be copied into an image gallery.  Avoid creating VMs directly
+	// from this URL as that may lead to performance limitations.
+	URL string `json:"url,omitempty"`
+}
diff --git a/vendor/github.com/coreos/stream-metadata-go/stream/stream.go b/vendor/github.com/coreos/stream-metadata-go/stream/stream.go
new file mode 100644
index 000000000..e3f100cea
--- /dev/null
+++ b/vendor/github.com/coreos/stream-metadata-go/stream/stream.go
@@ -0,0 +1,74 @@
+// Package stream models a CoreOS "stream", which is
+// a description of the recommended set of binary images for CoreOS.   Use
+// this API to find cloud images, bare metal disk images, etc.
+package stream
+
+import (
+	"github.com/coreos/stream-metadata-go/stream/rhcos"
+)
+
+// Stream contains artifacts available in a stream
+type Stream struct {
+	Stream        string          `json:"stream"`
+	Metadata      Metadata        `json:"metadata"`
+	Architectures map[string]Arch `json:"architectures"`
+}
+
+// Metadata for a release or stream
+type Metadata struct {
+	LastModified string `json:"last-modified"`
+}
+
+// Arch contains release details for a particular hardware architecture
+type Arch struct {
+	Artifacts map[string]PlatformArtifacts `json:"artifacts"`
+	Images    Images                       `json:"images,omitempty"`
+	// RHELCoreOSExtensions is data specific to Red Hat Enterprise Linux CoreOS
+	RHELCoreOSExtensions *rhcos.Extensions `json:"rhel-coreos-extensions,omitempty"`
+}
+
+// PlatformArtifacts contains images for a platform
+type PlatformArtifacts struct {
+	Release string                 `json:"release"`
+	Formats map[string]ImageFormat `json:"formats"`
+}
+
+// ImageFormat contains all artifacts for a single OS image
+type ImageFormat struct {
+	Disk      *Artifact `json:"disk,omitempty"`
+	Kernel    *Artifact `json:"kernel,omitempty"`
+	Initramfs *Artifact `json:"initramfs,omitempty"`
+	Rootfs    *Artifact `json:"rootfs,omitempty"`
+}
+
+// Artifact represents one image file, plus its metadata
+type Artifact struct {
+	Location           string `json:"location"`
+	Signature          string `json:"signature"`
+	Sha256             string `json:"sha256"`
+	UncompressedSha256 string `json:"uncompressed-sha256,omitempty"`
+}
+
+// Images contains images available in cloud providers
+type Images struct {
+	Aws *AwsImage `json:"aws,omitempty"`
+	Gcp *GcpImage `json:"gcp,omitempty"`
+}
+
+// AwsImage represents an image across all AWS regions
+type AwsImage struct {
+	Regions map[string]AwsRegionImage `json:"regions,omitempty"`
+}
+
+// AwsRegionImage represents an image in one AWS region
+type AwsRegionImage struct {
+	Release string `json:"release"`
+	Image   string `json:"image"`
+}
+
+// GcpImage represents a GCP cloud image
+type GcpImage struct {
+	Project string `json:"project,omitempty"`
+	Family  string `json:"family,omitempty"`
+	Name    string `json:"name,omitempty"`
+}
diff --git a/vendor/github.com/coreos/stream-metadata-go/stream/stream_utils.go b/vendor/github.com/coreos/stream-metadata-go/stream/stream_utils.go
new file mode 100644
index 000000000..ffd779c58
--- /dev/null
+++ b/vendor/github.com/coreos/stream-metadata-go/stream/stream_utils.go
@@ -0,0 +1,47 @@
+package stream
+
+import "fmt"
+
+// FormatPrefix describes a stream+architecture combination, intended for prepending to error messages
+func (st *Stream) FormatPrefix(archname string) string {
+	return fmt.Sprintf("%s/%s", st.Stream, archname)
+}
+
+// GetArchitecture loads the architecture-specific builds from a stream,
+// with a useful descriptive error message if the architecture is not found.
+func (st *Stream) GetArchitecture(archname string) (*Arch, error) {
+	archdata, ok := st.Architectures[archname]
+	if !ok {
+		return nil, fmt.Errorf("stream:%s does not have architecture '%s'", st.Stream, archname)
+	}
+	return &archdata, nil
+}
+
+// GetAwsRegionImage returns the release data (AMI and release ID) for a particular
+// architecture and region.
+func (st *Stream) GetAwsRegionImage(archname, region string) (*AwsRegionImage, error) {
+	starch, err := st.GetArchitecture(archname)
+	if err != nil {
+		return nil, err
+	}
+	awsimages := starch.Images.Aws
+	if awsimages == nil {
+		return nil, fmt.Errorf("%s: No AWS images", st.FormatPrefix(archname))
+	}
+	var regionVal AwsRegionImage
+	var ok bool
+	if regionVal, ok = awsimages.Regions[region]; !ok {
+		return nil, fmt.Errorf("%s: No AWS images in region %s", st.FormatPrefix(archname), region)
+	}
+
+	return &regionVal, nil
+}
+
+// GetAMI returns the AWS machine image for a particular architecture and region.
+func (st *Stream) GetAMI(archname, region string) (string, error) {
+	regionVal, err := st.GetAwsRegionImage(archname, region)
+	if err != nil {
+		return "", err
+	}
+	return regionVal.Image, nil
+}
diff --git a/vendor/github.com/digitalocean/go-libvirt/.travis.yml b/vendor/github.com/digitalocean/go-libvirt/.travis.yml
new file mode 100644
index 000000000..5852afcfd
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/.travis.yml
@@ -0,0 +1,62 @@
+language: go
+os: linux
+dist: bionic
+sudo: require
+
+cache:
+  directories:
+    - $HOME/.ccache
+
+go:
+  - "1.15"
+
+env:
+  global:
+    - CCACHE_TEMPDIR=/tmp/.ccache-temp
+  matrix:
+    - LIBVIRT=2.3.0  EXT=xz
+    - LIBVIRT=3.1.0  EXT=xz
+    - LIBVIRT=5.1.0  EXT=xz
+
+before_install:
+  - go get golang.org/x/lint/golint
+  - go get golang.org/x/tools/cmd/goyacc
+
+install:
+  # credit here goes to the go-libvirt authors,
+  # see: https://github.com/rgbkrk/libvirt-go/blob/master/.travis.yml
+  - sudo apt-get -qqy build-dep libvirt
+  - sudo apt-get -qqy install curl qemu-system-x86
+  - sudo mkdir -p /usr/src && sudo chown $(id -u) /usr/src
+  - curl -O -s https://libvirt.org/sources/libvirt-${LIBVIRT}.tar.${EXT}
+  - tar -C /usr/src -xf libvirt-${LIBVIRT}.tar.${EXT}
+  - pushd /usr/src/libvirt-${LIBVIRT}
+  - ccache --show-stats
+  - |
+        env PATH=/usr/lib/ccache:$PATH \
+        ./configure --prefix=/usr --localstatedir=/var --sysconfdir=/etc \
+                    --without-polkit \
+                    --without-esx --without-vbox --without-xen --without-libxl --without-lxc \
+                    --with-qemu
+  - make
+  - sudo make install
+  - ccache --show-stats
+  - popd
+  - sudo libvirtd -d -l -f libvirtd.conf
+  - sudo virtlogd -d || true
+
+before_script:
+  - go get -d ./...
+  - sudo qemu-img create -f raw -o size=10M /var/lib/libvirt/images/test.raw
+  - sudo virsh define .travis/test-domain.xml
+  - sudo virsh start test
+  - sudo virsh pool-create .travis/test-pool.xml
+  - sudo virsh secret-define .travis/test-secret.xml
+
+script:
+  - ./scripts/licensecheck.sh
+  - LIBVIRT_SOURCE=/usr/src/libvirt-${LIBVIRT} go generate ./...
+  - go build ./...
+  - golint -set_exit_status ./...
+  - go vet ./...
+  - go test -v -tags=integration ./...
diff --git a/vendor/github.com/digitalocean/go-libvirt/AUTHORS b/vendor/github.com/digitalocean/go-libvirt/AUTHORS
new file mode 100644
index 000000000..e004ab7a1
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/AUTHORS
@@ -0,0 +1,24 @@
+Maintainer
+----------
+DigitalOcean, Inc
+
+Original Authors
+----------------
+Ben LeMasurier	 <blemasurier@digitalocean.com>
+Matt Layher	 <mlayher@digitalocean.com>
+
+Contributors
+------------
+Justin Kim	 <justin@digitalocean.com>
+Ricky Medina	 <rm@do.co>
+Charlie Drage 	 <charlie@charliedrage.com>
+Michael Koppmann <me@mkoppmann.at>
+Simarpreet Singh <simar@linux.com>
+Alexander Polyakov <apolyakov@beget.com>
+Amanda Andrade <amanda.andrade@serpro.gov.br>
+Geoff Hickey <ghickey@digitalocean.com>
+Yuriy Taraday <yorik.sar@gmail.com>
+Sylvain Baubeau <sbaubeau@redhat.com>
+David Schneider <dsbrng25b@gmail.com>
+Alec Hothan <ahothan@gmail.com>
+Akos Varga <vrgakos@gmail.com>
\ No newline at end of file
diff --git a/vendor/github.com/digitalocean/go-libvirt/CONTRIBUTING.md b/vendor/github.com/digitalocean/go-libvirt/CONTRIBUTING.md
new file mode 100644
index 000000000..1b5b74106
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/CONTRIBUTING.md
@@ -0,0 +1,30 @@
+Contributing
+============
+
+The `go-libvirt` project makes use of the [GitHub Flow](https://guides.github.com/introduction/flow/)
+for contributions.
+
+If you'd like to contribute to the project, please
+[open an issue](https://github.com/digitalocean/go-libvirt/issues/new) or find an
+[existing issue](https://github.com/digitalocean/go-libvirt/issues) that you'd like
+to take on.  This ensures that efforts are not duplicated, and that a new feature
+aligns with the focus of the rest of the repository.
+
+Once your suggestion has been submitted and discussed, please be sure that your
+code meets the following criteria:
+  - code is completely `gofmt`'d
+  - new features or codepaths have appropriate test coverage
+  - `go test ./...` passes
+  - `go vet ./...` passes
+  - `golint ./...` returns no warnings, including documentation comment warnings
+
+In addition, if this is your first time contributing to the `go-libvirt` project,
+add your name and email address to the
+[AUTHORS](https://github.com/digitalocean/go-libvirt/blob/master/AUTHORS) file
+under the "Contributors" section using the format:
+`First Last <email@example.com>`.
+
+Finally, submit a pull request for review!
+
+Questions?  Feel free to join us in [`#go-qemu` on freenode](https://webchat.freenode.net/)
+if you'd like to discuss the project.
diff --git a/vendor/github.com/digitalocean/go-libvirt/LICENSE.md b/vendor/github.com/digitalocean/go-libvirt/LICENSE.md
new file mode 100644
index 000000000..f5f4b8b5e
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/LICENSE.md
@@ -0,0 +1,195 @@
+Apache License
+==============
+
+_Version 2.0, January 2004_  
+_&lt;<http://www.apache.org/licenses/>&gt;_
+
+### Terms and Conditions for use, reproduction, and distribution
+
+#### 1. Definitions
+
+“License” shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+“Licensor” shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+“Legal Entity” shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, “control” means **(i)** the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or **(ii)** ownership of fifty percent (50%) or more of the
+outstanding shares, or **(iii)** beneficial ownership of such entity.
+
+“You” (or “Your”) shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+“Source” form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+“Object” form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+“Work” shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+“Derivative Works” shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+“Contribution” shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+“submitted” means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as “Not a Contribution.”
+
+“Contributor” shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+#### 2. Grant of Copyright License
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+#### 3. Grant of Patent License
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+#### 4. Redistribution
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+* **(a)** You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+* **(b)** You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+* **(c)** You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+* **(d)** If the Work includes a “NOTICE” text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+#### 5. Submission of Contributions
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+#### 6. Trademarks
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+#### 7. Disclaimer of Warranty
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an “AS IS” BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+#### 8. Limitation of Liability
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+#### 9. Accepting Warranty or Additional Liability
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+_END OF TERMS AND CONDITIONS_
+
+### APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets `[]` replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same “printed page” as the copyright notice for easier identification within
+third-party archives.
+
+    Copyright [yyyy] [name of copyright owner]
+    
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+    
+      http://www.apache.org/licenses/LICENSE-2.0
+    
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
diff --git a/vendor/github.com/digitalocean/go-libvirt/README.md b/vendor/github.com/digitalocean/go-libvirt/README.md
new file mode 100644
index 000000000..125262612
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/README.md
@@ -0,0 +1,171 @@
+libvirt [![GoDoc](http://godoc.org/github.com/digitalocean/go-libvirt?status.svg)](http://godoc.org/github.com/digitalocean/go-libvirt) [![Build Status](https://travis-ci.org/digitalocean/go-libvirt.svg?branch=master)](https://travis-ci.org/digitalocean/go-libvirt) [![Report Card](https://goreportcard.com/badge/github.com/digitalocean/go-libvirt)](https://goreportcard.com/report/github.com/digitalocean/go-libvirt)
+====
+
+Package `go-libvirt` provides a pure Go interface for interacting with libvirt.
+
+Rather than using libvirt's C bindings, this package makes use of
+libvirt's RPC interface, as documented [here](https://libvirt.org/internals/rpc.html).
+Connections to the libvirt server may be local, or remote. RPC packets are encoded
+using the XDR standard as defined by [RFC 4506](https://tools.ietf.org/html/rfc4506.html).
+
+libvirt's RPC interface is quite extensive, and changes from one version to the
+next, so this project uses a pair of code generators to build the go bindings.
+The code generators should be run whenever you want to build go-libvirt for a
+new version of libvirt. See the next section for directions on re-generating
+go-libvirt.
+
+[Pull requests are welcome](https://github.com/digitalocean/go-libvirt/blob/master/CONTRIBUTING.md)!
+
+Running the Code Generators
+---------------------------
+
+The code generator doesn't run automatically when you build go-libvirt. It's
+meant to be run manually any time you change the version of libvirt you're
+using. When you download go-libvirt it will come with generated files
+corresponding to a particular version of libvirt. You can use the library as-is,
+but the generated code may be missing libvirt functions, if you're using a newer
+version of libvirt, or it may have extra functions that will return
+'unimplemented' errors if you try to call them. If this is a problem, you should
+re-run the code generator. To do this, follow these steps:
+
+- First, download a copy of the libvirt sources corresponding to the version you
+  want to use.
+- Next, run `autogen.sh` in the libvirt directory. The autotools will check for
+  necessary libraries and prepare libvirt for building. We don't actually need
+  to build libvirt, but we do require some header files that are produced in
+  this step.
+- Finally, set the environment variable `LIBVIRT_SOURCE` to the directory you
+  put libvirt into, and run `go generate ./...` from the go-libvirt directory.
+  This runs both of the go-libvirt's code generators.
+
+How to Use This Library
+-----------------------
+
+Once you've vendored go-libvirt into your project, you'll probably want to call
+some libvirt functions. There's some example code below showing how to connect
+to libvirt and make one such call, but once you get past the introduction you'll
+next want to call some other libvirt functions. How do you find them?
+
+Start with the [libvirt API reference](https://libvirt.org/html/index.html).
+Let's say you want to gracefully shutdown a VM, and after reading through the
+libvirt docs you determine that virDomainShutdown() is the function you want to
+call to do that. Where's that function in go-libvirt? We transform the names
+slightly when building the go bindings. There's no need for a global prefix like
+"vir" in Go, since all our functions are inside the package namespace, so we
+drop it. That means the Go function for `virDomainShutdown()` is just `DomainShutdown()`,
+and sure enough, you can find the Go function `DomainShutdown()` in libvirt.gen.go,
+with parameters and return values equivalent to those documented in the API
+reference.
+
+Suppose you then decide you need more control over your shutdown, so you switch
+over to `virDomainShutdownFlags()`. As its name suggests, this function takes a
+flag parameter which has possible values specified in an enum called
+`virDomainShutdownFlagValues`. Flag types like this are a little tricky for the
+code generator, because the C functions just take an integer type - only the
+libvirt documentation actually ties the flags to the enum types. In most cases
+though we're able to generate a wrapper function with a distinct flag type,
+making it easier for Go tooling to suggest possible flag values while you're
+working. Checking the documentation for this function:
+
+`godoc github.com/digitalocean/go-libvirt DomainShutdownFlags`
+
+returns this:
+
+`func (l *Libvirt) DomainShutdownFlags(Dom Domain, Flags DomainShutdownFlagValues) (err error)`
+
+If you want to see the possible flag values, `godoc` can help again:
+
+```
+$ godoc github.com/digitalocean/go-libvirt DomainShutdownFlagValues
+
+type DomainShutdownFlagValues int32
+    DomainShutdownFlagValues as declared in libvirt/libvirt-domain.h:1121
+
+const (
+    DomainShutdownDefault      DomainShutdownFlagValues = iota
+    DomainShutdownAcpiPowerBtn DomainShutdownFlagValues = 1
+    DomainShutdownGuestAgent   DomainShutdownFlagValues = 2
+    DomainShutdownInitctl      DomainShutdownFlagValues = 4
+    DomainShutdownSignal       DomainShutdownFlagValues = 8
+    DomainShutdownParavirt     DomainShutdownFlagValues = 16
+)
+    DomainShutdownFlagValues enumeration from libvirt/libvirt-domain.h:1121
+```
+
+One other suggestion: most of the code in go-libvirt is now generated, but a few
+hand-written routines still exist in libvirt.go, and wrap calls to the generated
+code with slightly different parameters or return values. We suggest avoiding
+these hand-written routines and calling the generated routines in libvirt.gen.go
+instead. Over time these handwritten routines will be removed from go-libvirt.
+
+Warning
+-------
+
+While these package are reasonably well-tested and have seen some use inside of
+DigitalOcean, there may be subtle bugs which could cause the packages to act
+in unexpected ways.  Use at your own risk!
+
+In addition, the API is not considered stable at this time.  If you would like
+to include package `libvirt` in a project, we highly recommend vendoring it into
+your project.
+
+Example
+-------
+
+```go
+package main
+
+import (
+	"fmt"
+	"log"
+	"net"
+	"time"
+
+	"github.com/digitalocean/go-libvirt"
+)
+
+func main() {
+	// This dials libvirt on the local machine, but you can substitute the first
+	// two parameters with "tcp", "<ip address>:<port>" to connect to libvirt on
+	// a remote machine.
+	c, err := net.DialTimeout("unix", "/var/run/libvirt/libvirt-sock", 2*time.Second)
+	if err != nil {
+		log.Fatalf("failed to dial libvirt: %v", err)
+	}
+
+	l := libvirt.New(c)
+	if err := l.Connect(); err != nil {
+		log.Fatalf("failed to connect: %v", err)
+	}
+
+	v, err := l.Version()
+	if err != nil {
+		log.Fatalf("failed to retrieve libvirt version: %v", err)
+	}
+	fmt.Println("Version:", v)
+
+	domains, err := l.Domains()
+	if err != nil {
+		log.Fatalf("failed to retrieve domains: %v", err)
+	}
+
+	fmt.Println("ID\tName\t\tUUID")
+	fmt.Printf("--------------------------------------------------------\n")
+	for _, d := range domains {
+		fmt.Printf("%d\t%s\t%x\n", d.ID, d.Name, d.UUID)
+	}
+
+	if err := l.Disconnect(); err != nil {
+		log.Fatalf("failed to disconnect: %v", err)
+	}
+}
+
+```
+
+```
+Version: 1.3.4
+ID	Name		UUID
+--------------------------------------------------------
+1	Test-1		dc329f87d4de47198cfd2e21c6105b01
+2	Test-2		dc229f87d4de47198cfd2e21c6105b01
+```
diff --git a/vendor/github.com/digitalocean/go-libvirt/const.gen.go b/vendor/github.com/digitalocean/go-libvirt/const.gen.go
new file mode 100644
index 000000000..6e581d22c
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/const.gen.go
@@ -0,0 +1,2414 @@
+// Copyright 2018 The go-libvirt Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// WARNING: This file has automatically been generated
+// Code generated by https://git.io/c-for-go. DO NOT EDIT.
+
+package libvirt
+
+const (
+	// ExportVar as defined in libvirt/libvirt-common.h:57
+	ExportVar = 0
+	// TypedParamFieldLength as defined in libvirt/libvirt-common.h:170
+	TypedParamFieldLength = 80
+	// SecurityLabelBuflen as defined in libvirt/libvirt-host.h:84
+	SecurityLabelBuflen = 4097
+	// SecurityModelBuflen as defined in libvirt/libvirt-host.h:112
+	SecurityModelBuflen = 257
+	// SecurityDoiBuflen as defined in libvirt/libvirt-host.h:119
+	SecurityDoiBuflen = 257
+	// NodeCPUStatsFieldLength as defined in libvirt/libvirt-host.h:180
+	NodeCPUStatsFieldLength = 80
+	// NodeCPUStatsKernel as defined in libvirt/libvirt-host.h:197
+	NodeCPUStatsKernel = "kernel"
+	// NodeCPUStatsUser as defined in libvirt/libvirt-host.h:205
+	NodeCPUStatsUser = "user"
+	// NodeCPUStatsIdle as defined in libvirt/libvirt-host.h:213
+	NodeCPUStatsIdle = "idle"
+	// NodeCPUStatsIowait as defined in libvirt/libvirt-host.h:221
+	NodeCPUStatsIowait = "iowait"
+	// NodeCPUStatsIntr as defined in libvirt/libvirt-host.h:229
+	NodeCPUStatsIntr = "intr"
+	// NodeCPUStatsUtilization as defined in libvirt/libvirt-host.h:238
+	NodeCPUStatsUtilization = "utilization"
+	// NodeMemoryStatsFieldLength as defined in libvirt/libvirt-host.h:258
+	NodeMemoryStatsFieldLength = 80
+	// NodeMemoryStatsTotal as defined in libvirt/libvirt-host.h:275
+	NodeMemoryStatsTotal = "total"
+	// NodeMemoryStatsFree as defined in libvirt/libvirt-host.h:284
+	NodeMemoryStatsFree = "free"
+	// NodeMemoryStatsBuffers as defined in libvirt/libvirt-host.h:292
+	NodeMemoryStatsBuffers = "buffers"
+	// NodeMemoryStatsCached as defined in libvirt/libvirt-host.h:300
+	NodeMemoryStatsCached = "cached"
+	// NodeMemorySharedPagesToScan as defined in libvirt/libvirt-host.h:321
+	NodeMemorySharedPagesToScan = "shm_pages_to_scan"
+	// NodeMemorySharedSleepMillisecs as defined in libvirt/libvirt-host.h:329
+	NodeMemorySharedSleepMillisecs = "shm_sleep_millisecs"
+	// NodeMemorySharedPagesShared as defined in libvirt/libvirt-host.h:337
+	NodeMemorySharedPagesShared = "shm_pages_shared"
+	// NodeMemorySharedPagesSharing as defined in libvirt/libvirt-host.h:345
+	NodeMemorySharedPagesSharing = "shm_pages_sharing"
+	// NodeMemorySharedPagesUnshared as defined in libvirt/libvirt-host.h:353
+	NodeMemorySharedPagesUnshared = "shm_pages_unshared"
+	// NodeMemorySharedPagesVolatile as defined in libvirt/libvirt-host.h:361
+	NodeMemorySharedPagesVolatile = "shm_pages_volatile"
+	// NodeMemorySharedFullScans as defined in libvirt/libvirt-host.h:369
+	NodeMemorySharedFullScans = "shm_full_scans"
+	// NodeMemorySharedMergeAcrossNodes as defined in libvirt/libvirt-host.h:381
+	NodeMemorySharedMergeAcrossNodes = "shm_merge_across_nodes"
+	// NodeSevPdh as defined in libvirt/libvirt-host.h:449
+	NodeSevPdh = "pdh"
+	// NodeSevCertChain as defined in libvirt/libvirt-host.h:458
+	NodeSevCertChain = "cert-chain"
+	// NodeSevCbitpos as defined in libvirt/libvirt-host.h:465
+	NodeSevCbitpos = "cbitpos"
+	// NodeSevReducedPhysBits as defined in libvirt/libvirt-host.h:473
+	NodeSevReducedPhysBits = "reduced-phys-bits"
+	// UUIDBuflen as defined in libvirt/libvirt-host.h:558
+	UUIDBuflen = 16
+	// UUIDStringBuflen as defined in libvirt/libvirt-host.h:567
+	UUIDStringBuflen = 37
+	// ConnectIdentityUserName as defined in libvirt/libvirt-host.h:592
+	ConnectIdentityUserName = "user-name"
+	// ConnectIdentityUnixUserID as defined in libvirt/libvirt-host.h:599
+	ConnectIdentityUnixUserID = "unix-user-id"
+	// ConnectIdentityGroupName as defined in libvirt/libvirt-host.h:606
+	ConnectIdentityGroupName = "group-name"
+	// ConnectIdentityUnixGroupID as defined in libvirt/libvirt-host.h:613
+	ConnectIdentityUnixGroupID = "unix-group-id"
+	// ConnectIdentityProcessID as defined in libvirt/libvirt-host.h:620
+	ConnectIdentityProcessID = "process-id"
+	// ConnectIdentityProcessTime as defined in libvirt/libvirt-host.h:631
+	ConnectIdentityProcessTime = "process-time"
+	// ConnectIdentitySaslUserName as defined in libvirt/libvirt-host.h:638
+	ConnectIdentitySaslUserName = "sasl-user-name"
+	// ConnectIdentityX509DistinguishedName as defined in libvirt/libvirt-host.h:645
+	ConnectIdentityX509DistinguishedName = "x509-distinguished-name"
+	// ConnectIdentitySelinuxContext as defined in libvirt/libvirt-host.h:652
+	ConnectIdentitySelinuxContext = "selinux-context"
+	// DomainSchedulerCPUShares as defined in libvirt/libvirt-domain.h:316
+	DomainSchedulerCPUShares = "cpu_shares"
+	// DomainSchedulerGlobalPeriod as defined in libvirt/libvirt-domain.h:324
+	DomainSchedulerGlobalPeriod = "global_period"
+	// DomainSchedulerGlobalQuota as defined in libvirt/libvirt-domain.h:332
+	DomainSchedulerGlobalQuota = "global_quota"
+	// DomainSchedulerVCPUPeriod as defined in libvirt/libvirt-domain.h:340
+	DomainSchedulerVCPUPeriod = "vcpu_period"
+	// DomainSchedulerVCPUQuota as defined in libvirt/libvirt-domain.h:348
+	DomainSchedulerVCPUQuota = "vcpu_quota"
+	// DomainSchedulerEmulatorPeriod as defined in libvirt/libvirt-domain.h:357
+	DomainSchedulerEmulatorPeriod = "emulator_period"
+	// DomainSchedulerEmulatorQuota as defined in libvirt/libvirt-domain.h:366
+	DomainSchedulerEmulatorQuota = "emulator_quota"
+	// DomainSchedulerIothreadPeriod as defined in libvirt/libvirt-domain.h:374
+	DomainSchedulerIothreadPeriod = "iothread_period"
+	// DomainSchedulerIothreadQuota as defined in libvirt/libvirt-domain.h:382
+	DomainSchedulerIothreadQuota = "iothread_quota"
+	// DomainSchedulerWeight as defined in libvirt/libvirt-domain.h:390
+	DomainSchedulerWeight = "weight"
+	// DomainSchedulerCap as defined in libvirt/libvirt-domain.h:398
+	DomainSchedulerCap = "cap"
+	// DomainSchedulerReservation as defined in libvirt/libvirt-domain.h:406
+	DomainSchedulerReservation = "reservation"
+	// DomainSchedulerLimit as defined in libvirt/libvirt-domain.h:414
+	DomainSchedulerLimit = "limit"
+	// DomainSchedulerShares as defined in libvirt/libvirt-domain.h:422
+	DomainSchedulerShares = "shares"
+	// DomainBlockStatsFieldLength as defined in libvirt/libvirt-domain.h:480
+	DomainBlockStatsFieldLength = 80
+	// DomainBlockStatsReadBytes as defined in libvirt/libvirt-domain.h:488
+	DomainBlockStatsReadBytes = "rd_bytes"
+	// DomainBlockStatsReadReq as defined in libvirt/libvirt-domain.h:496
+	DomainBlockStatsReadReq = "rd_operations"
+	// DomainBlockStatsReadTotalTimes as defined in libvirt/libvirt-domain.h:504
+	DomainBlockStatsReadTotalTimes = "rd_total_times"
+	// DomainBlockStatsWriteBytes as defined in libvirt/libvirt-domain.h:512
+	DomainBlockStatsWriteBytes = "wr_bytes"
+	// DomainBlockStatsWriteReq as defined in libvirt/libvirt-domain.h:520
+	DomainBlockStatsWriteReq = "wr_operations"
+	// DomainBlockStatsWriteTotalTimes as defined in libvirt/libvirt-domain.h:528
+	DomainBlockStatsWriteTotalTimes = "wr_total_times"
+	// DomainBlockStatsFlushReq as defined in libvirt/libvirt-domain.h:536
+	DomainBlockStatsFlushReq = "flush_operations"
+	// DomainBlockStatsFlushTotalTimes as defined in libvirt/libvirt-domain.h:544
+	DomainBlockStatsFlushTotalTimes = "flush_total_times"
+	// DomainBlockStatsErrs as defined in libvirt/libvirt-domain.h:551
+	DomainBlockStatsErrs = "errs"
+	// MigrateParamURI as defined in libvirt/libvirt-domain.h:868
+	MigrateParamURI = "migrate_uri"
+	// MigrateParamDestName as defined in libvirt/libvirt-domain.h:878
+	MigrateParamDestName = "destination_name"
+	// MigrateParamDestXML as defined in libvirt/libvirt-domain.h:897
+	MigrateParamDestXML = "destination_xml"
+	// MigrateParamPersistXML as defined in libvirt/libvirt-domain.h:912
+	MigrateParamPersistXML = "persistent_xml"
+	// MigrateParamBandwidth as defined in libvirt/libvirt-domain.h:922
+	MigrateParamBandwidth = "bandwidth"
+	// MigrateParamBandwidthPostcopy as defined in libvirt/libvirt-domain.h:931
+	MigrateParamBandwidthPostcopy = "bandwidth.postcopy"
+	// MigrateParamGraphicsURI as defined in libvirt/libvirt-domain.h:952
+	MigrateParamGraphicsURI = "graphics_uri"
+	// MigrateParamListenAddress as defined in libvirt/libvirt-domain.h:963
+	MigrateParamListenAddress = "listen_address"
+	// MigrateParamMigrateDisks as defined in libvirt/libvirt-domain.h:972
+	MigrateParamMigrateDisks = "migrate_disks"
+	// MigrateParamDisksPort as defined in libvirt/libvirt-domain.h:982
+	MigrateParamDisksPort = "disks_port"
+	// MigrateParamCompression as defined in libvirt/libvirt-domain.h:992
+	MigrateParamCompression = "compression"
+	// MigrateParamCompressionMtLevel as defined in libvirt/libvirt-domain.h:1001
+	MigrateParamCompressionMtLevel = "compression.mt.level"
+	// MigrateParamCompressionMtThreads as defined in libvirt/libvirt-domain.h:1009
+	MigrateParamCompressionMtThreads = "compression.mt.threads"
+	// MigrateParamCompressionMtDthreads as defined in libvirt/libvirt-domain.h:1017
+	MigrateParamCompressionMtDthreads = "compression.mt.dthreads"
+	// MigrateParamCompressionXbzrleCache as defined in libvirt/libvirt-domain.h:1025
+	MigrateParamCompressionXbzrleCache = "compression.xbzrle.cache"
+	// MigrateParamAutoConvergeInitial as defined in libvirt/libvirt-domain.h:1034
+	MigrateParamAutoConvergeInitial = "auto_converge.initial"
+	// MigrateParamAutoConvergeIncrement as defined in libvirt/libvirt-domain.h:1044
+	MigrateParamAutoConvergeIncrement = "auto_converge.increment"
+	// MigrateParamParallelConnections as defined in libvirt/libvirt-domain.h:1052
+	MigrateParamParallelConnections = "parallel.connections"
+	// MigrateParamTLSDestination as defined in libvirt/libvirt-domain.h:1066
+	MigrateParamTLSDestination = "tls.destination"
+	// DomainCPUStatsCputime as defined in libvirt/libvirt-domain.h:1326
+	DomainCPUStatsCputime = "cpu_time"
+	// DomainCPUStatsUsertime as defined in libvirt/libvirt-domain.h:1332
+	DomainCPUStatsUsertime = "user_time"
+	// DomainCPUStatsSystemtime as defined in libvirt/libvirt-domain.h:1338
+	DomainCPUStatsSystemtime = "system_time"
+	// DomainCPUStatsVcputime as defined in libvirt/libvirt-domain.h:1345
+	DomainCPUStatsVcputime = "vcpu_time"
+	// DomainBlkioWeight as defined in libvirt/libvirt-domain.h:1374
+	DomainBlkioWeight = "weight"
+	// DomainBlkioDeviceWeight as defined in libvirt/libvirt-domain.h:1384
+	DomainBlkioDeviceWeight = "device_weight"
+	// DomainBlkioDeviceReadIops as defined in libvirt/libvirt-domain.h:1395
+	DomainBlkioDeviceReadIops = "device_read_iops_sec"
+	// DomainBlkioDeviceWriteIops as defined in libvirt/libvirt-domain.h:1406
+	DomainBlkioDeviceWriteIops = "device_write_iops_sec"
+	// DomainBlkioDeviceReadBps as defined in libvirt/libvirt-domain.h:1417
+	DomainBlkioDeviceReadBps = "device_read_bytes_sec"
+	// DomainBlkioDeviceWriteBps as defined in libvirt/libvirt-domain.h:1428
+	DomainBlkioDeviceWriteBps = "device_write_bytes_sec"
+	// DomainMemoryParamUnlimited as defined in libvirt/libvirt-domain.h:1447
+	DomainMemoryParamUnlimited = 9007199254740991
+	// DomainMemoryHardLimit as defined in libvirt/libvirt-domain.h:1456
+	DomainMemoryHardLimit = "hard_limit"
+	// DomainMemorySoftLimit as defined in libvirt/libvirt-domain.h:1465
+	DomainMemorySoftLimit = "soft_limit"
+	// DomainMemoryMinGuarantee as defined in libvirt/libvirt-domain.h:1474
+	DomainMemoryMinGuarantee = "min_guarantee"
+	// DomainMemorySwapHardLimit as defined in libvirt/libvirt-domain.h:1484
+	DomainMemorySwapHardLimit = "swap_hard_limit"
+	// DomainNumaNodeset as defined in libvirt/libvirt-domain.h:1529
+	DomainNumaNodeset = "numa_nodeset"
+	// DomainNumaMode as defined in libvirt/libvirt-domain.h:1537
+	DomainNumaMode = "numa_mode"
+	// DomainBandwidthInAverage as defined in libvirt/libvirt-domain.h:1653
+	DomainBandwidthInAverage = "inbound.average"
+	// DomainBandwidthInPeak as defined in libvirt/libvirt-domain.h:1660
+	DomainBandwidthInPeak = "inbound.peak"
+	// DomainBandwidthInBurst as defined in libvirt/libvirt-domain.h:1667
+	DomainBandwidthInBurst = "inbound.burst"
+	// DomainBandwidthInFloor as defined in libvirt/libvirt-domain.h:1674
+	DomainBandwidthInFloor = "inbound.floor"
+	// DomainBandwidthOutAverage as defined in libvirt/libvirt-domain.h:1681
+	DomainBandwidthOutAverage = "outbound.average"
+	// DomainBandwidthOutPeak as defined in libvirt/libvirt-domain.h:1688
+	DomainBandwidthOutPeak = "outbound.peak"
+	// DomainBandwidthOutBurst as defined in libvirt/libvirt-domain.h:1695
+	DomainBandwidthOutBurst = "outbound.burst"
+	// DomainIothreadPollMaxNs as defined in libvirt/libvirt-domain.h:1995
+	DomainIothreadPollMaxNs = "poll_max_ns"
+	// DomainIothreadPollGrow as defined in libvirt/libvirt-domain.h:2005
+	DomainIothreadPollGrow = "poll_grow"
+	// DomainIothreadPollShrink as defined in libvirt/libvirt-domain.h:2016
+	DomainIothreadPollShrink = "poll_shrink"
+	// PerfParamCmt as defined in libvirt/libvirt-domain.h:2208
+	PerfParamCmt = "cmt"
+	// PerfParamMbmt as defined in libvirt/libvirt-domain.h:2219
+	PerfParamMbmt = "mbmt"
+	// PerfParamMbml as defined in libvirt/libvirt-domain.h:2229
+	PerfParamMbml = "mbml"
+	// PerfParamCacheMisses as defined in libvirt/libvirt-domain.h:2239
+	PerfParamCacheMisses = "cache_misses"
+	// PerfParamCacheReferences as defined in libvirt/libvirt-domain.h:2249
+	PerfParamCacheReferences = "cache_references"
+	// PerfParamInstructions as defined in libvirt/libvirt-domain.h:2259
+	PerfParamInstructions = "instructions"
+	// PerfParamCPUCycles as defined in libvirt/libvirt-domain.h:2269
+	PerfParamCPUCycles = "cpu_cycles"
+	// PerfParamBranchInstructions as defined in libvirt/libvirt-domain.h:2279
+	PerfParamBranchInstructions = "branch_instructions"
+	// PerfParamBranchMisses as defined in libvirt/libvirt-domain.h:2289
+	PerfParamBranchMisses = "branch_misses"
+	// PerfParamBusCycles as defined in libvirt/libvirt-domain.h:2299
+	PerfParamBusCycles = "bus_cycles"
+	// PerfParamStalledCyclesFrontend as defined in libvirt/libvirt-domain.h:2310
+	PerfParamStalledCyclesFrontend = "stalled_cycles_frontend"
+	// PerfParamStalledCyclesBackend as defined in libvirt/libvirt-domain.h:2321
+	PerfParamStalledCyclesBackend = "stalled_cycles_backend"
+	// PerfParamRefCPUCycles as defined in libvirt/libvirt-domain.h:2332
+	PerfParamRefCPUCycles = "ref_cpu_cycles"
+	// PerfParamCPUClock as defined in libvirt/libvirt-domain.h:2343
+	PerfParamCPUClock = "cpu_clock"
+	// PerfParamTaskClock as defined in libvirt/libvirt-domain.h:2354
+	PerfParamTaskClock = "task_clock"
+	// PerfParamPageFaults as defined in libvirt/libvirt-domain.h:2364
+	PerfParamPageFaults = "page_faults"
+	// PerfParamContextSwitches as defined in libvirt/libvirt-domain.h:2374
+	PerfParamContextSwitches = "context_switches"
+	// PerfParamCPUMigrations as defined in libvirt/libvirt-domain.h:2384
+	PerfParamCPUMigrations = "cpu_migrations"
+	// PerfParamPageFaultsMin as defined in libvirt/libvirt-domain.h:2394
+	PerfParamPageFaultsMin = "page_faults_min"
+	// PerfParamPageFaultsMaj as defined in libvirt/libvirt-domain.h:2404
+	PerfParamPageFaultsMaj = "page_faults_maj"
+	// PerfParamAlignmentFaults as defined in libvirt/libvirt-domain.h:2414
+	PerfParamAlignmentFaults = "alignment_faults"
+	// PerfParamEmulationFaults as defined in libvirt/libvirt-domain.h:2424
+	PerfParamEmulationFaults = "emulation_faults"
+	// DomainBlockCopyBandwidth as defined in libvirt/libvirt-domain.h:2592
+	DomainBlockCopyBandwidth = "bandwidth"
+	// DomainBlockCopyGranularity as defined in libvirt/libvirt-domain.h:2603
+	DomainBlockCopyGranularity = "granularity"
+	// DomainBlockCopyBufSize as defined in libvirt/libvirt-domain.h:2612
+	DomainBlockCopyBufSize = "buf-size"
+	// DomainBlockIotuneTotalBytesSec as defined in libvirt/libvirt-domain.h:2653
+	DomainBlockIotuneTotalBytesSec = "total_bytes_sec"
+	// DomainBlockIotuneReadBytesSec as defined in libvirt/libvirt-domain.h:2661
+	DomainBlockIotuneReadBytesSec = "read_bytes_sec"
+	// DomainBlockIotuneWriteBytesSec as defined in libvirt/libvirt-domain.h:2669
+	DomainBlockIotuneWriteBytesSec = "write_bytes_sec"
+	// DomainBlockIotuneTotalIopsSec as defined in libvirt/libvirt-domain.h:2677
+	DomainBlockIotuneTotalIopsSec = "total_iops_sec"
+	// DomainBlockIotuneReadIopsSec as defined in libvirt/libvirt-domain.h:2685
+	DomainBlockIotuneReadIopsSec = "read_iops_sec"
+	// DomainBlockIotuneWriteIopsSec as defined in libvirt/libvirt-domain.h:2692
+	DomainBlockIotuneWriteIopsSec = "write_iops_sec"
+	// DomainBlockIotuneTotalBytesSecMax as defined in libvirt/libvirt-domain.h:2700
+	DomainBlockIotuneTotalBytesSecMax = "total_bytes_sec_max"
+	// DomainBlockIotuneReadBytesSecMax as defined in libvirt/libvirt-domain.h:2708
+	DomainBlockIotuneReadBytesSecMax = "read_bytes_sec_max"
+	// DomainBlockIotuneWriteBytesSecMax as defined in libvirt/libvirt-domain.h:2716
+	DomainBlockIotuneWriteBytesSecMax = "write_bytes_sec_max"
+	// DomainBlockIotuneTotalIopsSecMax as defined in libvirt/libvirt-domain.h:2724
+	DomainBlockIotuneTotalIopsSecMax = "total_iops_sec_max"
+	// DomainBlockIotuneReadIopsSecMax as defined in libvirt/libvirt-domain.h:2732
+	DomainBlockIotuneReadIopsSecMax = "read_iops_sec_max"
+	// DomainBlockIotuneWriteIopsSecMax as defined in libvirt/libvirt-domain.h:2739
+	DomainBlockIotuneWriteIopsSecMax = "write_iops_sec_max"
+	// DomainBlockIotuneTotalBytesSecMaxLength as defined in libvirt/libvirt-domain.h:2747
+	DomainBlockIotuneTotalBytesSecMaxLength = "total_bytes_sec_max_length"
+	// DomainBlockIotuneReadBytesSecMaxLength as defined in libvirt/libvirt-domain.h:2755
+	DomainBlockIotuneReadBytesSecMaxLength = "read_bytes_sec_max_length"
+	// DomainBlockIotuneWriteBytesSecMaxLength as defined in libvirt/libvirt-domain.h:2763
+	DomainBlockIotuneWriteBytesSecMaxLength = "write_bytes_sec_max_length"
+	// DomainBlockIotuneTotalIopsSecMaxLength as defined in libvirt/libvirt-domain.h:2771
+	DomainBlockIotuneTotalIopsSecMaxLength = "total_iops_sec_max_length"
+	// DomainBlockIotuneReadIopsSecMaxLength as defined in libvirt/libvirt-domain.h:2779
+	DomainBlockIotuneReadIopsSecMaxLength = "read_iops_sec_max_length"
+	// DomainBlockIotuneWriteIopsSecMaxLength as defined in libvirt/libvirt-domain.h:2787
+	DomainBlockIotuneWriteIopsSecMaxLength = "write_iops_sec_max_length"
+	// DomainBlockIotuneSizeIopsSec as defined in libvirt/libvirt-domain.h:2794
+	DomainBlockIotuneSizeIopsSec = "size_iops_sec"
+	// DomainBlockIotuneGroupName as defined in libvirt/libvirt-domain.h:2801
+	DomainBlockIotuneGroupName = "group_name"
+	// KeycodeSetRfb as defined in libvirt/libvirt-domain.h:2882
+	KeycodeSetRfb = 0
+	// DomainSendKeyMaxKeys as defined in libvirt/libvirt-domain.h:2889
+	DomainSendKeyMaxKeys = 16
+	// DomainJobOperationStr as defined in libvirt/libvirt-domain.h:3304
+	DomainJobOperationStr = "operation"
+	// DomainJobTimeElapsed as defined in libvirt/libvirt-domain.h:3314
+	DomainJobTimeElapsed = "time_elapsed"
+	// DomainJobTimeElapsedNet as defined in libvirt/libvirt-domain.h:3324
+	DomainJobTimeElapsedNet = "time_elapsed_net"
+	// DomainJobTimeRemaining as defined in libvirt/libvirt-domain.h:3334
+	DomainJobTimeRemaining = "time_remaining"
+	// DomainJobDowntime as defined in libvirt/libvirt-domain.h:3344
+	DomainJobDowntime = "downtime"
+	// DomainJobDowntimeNet as defined in libvirt/libvirt-domain.h:3353
+	DomainJobDowntimeNet = "downtime_net"
+	// DomainJobSetupTime as defined in libvirt/libvirt-domain.h:3362
+	DomainJobSetupTime = "setup_time"
+	// DomainJobDataTotal as defined in libvirt/libvirt-domain.h:3377
+	DomainJobDataTotal = "data_total"
+	// DomainJobDataProcessed as defined in libvirt/libvirt-domain.h:3387
+	DomainJobDataProcessed = "data_processed"
+	// DomainJobDataRemaining as defined in libvirt/libvirt-domain.h:3397
+	DomainJobDataRemaining = "data_remaining"
+	// DomainJobMemoryTotal as defined in libvirt/libvirt-domain.h:3407
+	DomainJobMemoryTotal = "memory_total"
+	// DomainJobMemoryProcessed as defined in libvirt/libvirt-domain.h:3417
+	DomainJobMemoryProcessed = "memory_processed"
+	// DomainJobMemoryRemaining as defined in libvirt/libvirt-domain.h:3427
+	DomainJobMemoryRemaining = "memory_remaining"
+	// DomainJobMemoryConstant as defined in libvirt/libvirt-domain.h:3439
+	DomainJobMemoryConstant = "memory_constant"
+	// DomainJobMemoryNormal as defined in libvirt/libvirt-domain.h:3449
+	DomainJobMemoryNormal = "memory_normal"
+	// DomainJobMemoryNormalBytes as defined in libvirt/libvirt-domain.h:3459
+	DomainJobMemoryNormalBytes = "memory_normal_bytes"
+	// DomainJobMemoryBps as defined in libvirt/libvirt-domain.h:3467
+	DomainJobMemoryBps = "memory_bps"
+	// DomainJobMemoryDirtyRate as defined in libvirt/libvirt-domain.h:3475
+	DomainJobMemoryDirtyRate = "memory_dirty_rate"
+	// DomainJobMemoryPageSize as defined in libvirt/libvirt-domain.h:3486
+	DomainJobMemoryPageSize = "memory_page_size"
+	// DomainJobMemoryIteration as defined in libvirt/libvirt-domain.h:3497
+	DomainJobMemoryIteration = "memory_iteration"
+	// DomainJobMemoryPostcopyReqs as defined in libvirt/libvirt-domain.h:3507
+	DomainJobMemoryPostcopyReqs = "memory_postcopy_requests"
+	// DomainJobDiskTotal as defined in libvirt/libvirt-domain.h:3517
+	DomainJobDiskTotal = "disk_total"
+	// DomainJobDiskProcessed as defined in libvirt/libvirt-domain.h:3527
+	DomainJobDiskProcessed = "disk_processed"
+	// DomainJobDiskRemaining as defined in libvirt/libvirt-domain.h:3537
+	DomainJobDiskRemaining = "disk_remaining"
+	// DomainJobDiskBps as defined in libvirt/libvirt-domain.h:3545
+	DomainJobDiskBps = "disk_bps"
+	// DomainJobCompressionCache as defined in libvirt/libvirt-domain.h:3554
+	DomainJobCompressionCache = "compression_cache"
+	// DomainJobCompressionBytes as defined in libvirt/libvirt-domain.h:3562
+	DomainJobCompressionBytes = "compression_bytes"
+	// DomainJobCompressionPages as defined in libvirt/libvirt-domain.h:3570
+	DomainJobCompressionPages = "compression_pages"
+	// DomainJobCompressionCacheMisses as defined in libvirt/libvirt-domain.h:3579
+	DomainJobCompressionCacheMisses = "compression_cache_misses"
+	// DomainJobCompressionOverflow as defined in libvirt/libvirt-domain.h:3589
+	DomainJobCompressionOverflow = "compression_overflow"
+	// DomainJobAutoConvergeThrottle as defined in libvirt/libvirt-domain.h:3598
+	DomainJobAutoConvergeThrottle = "auto_converge_throttle"
+	// DomainJobSuccess as defined in libvirt/libvirt-domain.h:3606
+	DomainJobSuccess = "success"
+	// DomainJobDiskTempUsed as defined in libvirt/libvirt-domain.h:3613
+	DomainJobDiskTempUsed = "disk_temp_used"
+	// DomainJobDiskTempTotal as defined in libvirt/libvirt-domain.h:3620
+	DomainJobDiskTempTotal = "disk_temp_total"
+	// DomainTunableCPUVcpupin as defined in libvirt/libvirt-domain.h:4175
+	DomainTunableCPUVcpupin = "cputune.vcpupin%u"
+	// DomainTunableCPUEmulatorpin as defined in libvirt/libvirt-domain.h:4183
+	DomainTunableCPUEmulatorpin = "cputune.emulatorpin"
+	// DomainTunableCPUIothreadspin as defined in libvirt/libvirt-domain.h:4192
+	DomainTunableCPUIothreadspin = "cputune.iothreadpin%u"
+	// DomainTunableCPUCpuShares as defined in libvirt/libvirt-domain.h:4200
+	DomainTunableCPUCpuShares = "cputune.cpu_shares"
+	// DomainTunableCPUGlobalPeriod as defined in libvirt/libvirt-domain.h:4208
+	DomainTunableCPUGlobalPeriod = "cputune.global_period"
+	// DomainTunableCPUGlobalQuota as defined in libvirt/libvirt-domain.h:4216
+	DomainTunableCPUGlobalQuota = "cputune.global_quota"
+	// DomainTunableCPUVCPUPeriod as defined in libvirt/libvirt-domain.h:4224
+	DomainTunableCPUVCPUPeriod = "cputune.vcpu_period"
+	// DomainTunableCPUVCPUQuota as defined in libvirt/libvirt-domain.h:4232
+	DomainTunableCPUVCPUQuota = "cputune.vcpu_quota"
+	// DomainTunableCPUEmulatorPeriod as defined in libvirt/libvirt-domain.h:4241
+	DomainTunableCPUEmulatorPeriod = "cputune.emulator_period"
+	// DomainTunableCPUEmulatorQuota as defined in libvirt/libvirt-domain.h:4250
+	DomainTunableCPUEmulatorQuota = "cputune.emulator_quota"
+	// DomainTunableCPUIothreadPeriod as defined in libvirt/libvirt-domain.h:4258
+	DomainTunableCPUIothreadPeriod = "cputune.iothread_period"
+	// DomainTunableCPUIothreadQuota as defined in libvirt/libvirt-domain.h:4266
+	DomainTunableCPUIothreadQuota = "cputune.iothread_quota"
+	// DomainTunableBlkdevDisk as defined in libvirt/libvirt-domain.h:4274
+	DomainTunableBlkdevDisk = "blkdeviotune.disk"
+	// DomainTunableBlkdevTotalBytesSec as defined in libvirt/libvirt-domain.h:4282
+	DomainTunableBlkdevTotalBytesSec = "blkdeviotune.total_bytes_sec"
+	// DomainTunableBlkdevReadBytesSec as defined in libvirt/libvirt-domain.h:4290
+	DomainTunableBlkdevReadBytesSec = "blkdeviotune.read_bytes_sec"
+	// DomainTunableBlkdevWriteBytesSec as defined in libvirt/libvirt-domain.h:4298
+	DomainTunableBlkdevWriteBytesSec = "blkdeviotune.write_bytes_sec"
+	// DomainTunableBlkdevTotalIopsSec as defined in libvirt/libvirt-domain.h:4306
+	DomainTunableBlkdevTotalIopsSec = "blkdeviotune.total_iops_sec"
+	// DomainTunableBlkdevReadIopsSec as defined in libvirt/libvirt-domain.h:4314
+	DomainTunableBlkdevReadIopsSec = "blkdeviotune.read_iops_sec"
+	// DomainTunableBlkdevWriteIopsSec as defined in libvirt/libvirt-domain.h:4322
+	DomainTunableBlkdevWriteIopsSec = "blkdeviotune.write_iops_sec"
+	// DomainTunableBlkdevTotalBytesSecMax as defined in libvirt/libvirt-domain.h:4330
+	DomainTunableBlkdevTotalBytesSecMax = "blkdeviotune.total_bytes_sec_max"
+	// DomainTunableBlkdevReadBytesSecMax as defined in libvirt/libvirt-domain.h:4338
+	DomainTunableBlkdevReadBytesSecMax = "blkdeviotune.read_bytes_sec_max"
+	// DomainTunableBlkdevWriteBytesSecMax as defined in libvirt/libvirt-domain.h:4346
+	DomainTunableBlkdevWriteBytesSecMax = "blkdeviotune.write_bytes_sec_max"
+	// DomainTunableBlkdevTotalIopsSecMax as defined in libvirt/libvirt-domain.h:4354
+	DomainTunableBlkdevTotalIopsSecMax = "blkdeviotune.total_iops_sec_max"
+	// DomainTunableBlkdevReadIopsSecMax as defined in libvirt/libvirt-domain.h:4362
+	DomainTunableBlkdevReadIopsSecMax = "blkdeviotune.read_iops_sec_max"
+	// DomainTunableBlkdevWriteIopsSecMax as defined in libvirt/libvirt-domain.h:4370
+	DomainTunableBlkdevWriteIopsSecMax = "blkdeviotune.write_iops_sec_max"
+	// DomainTunableBlkdevSizeIopsSec as defined in libvirt/libvirt-domain.h:4378
+	DomainTunableBlkdevSizeIopsSec = "blkdeviotune.size_iops_sec"
+	// DomainTunableBlkdevGroupName as defined in libvirt/libvirt-domain.h:4386
+	DomainTunableBlkdevGroupName = "blkdeviotune.group_name"
+	// DomainTunableBlkdevTotalBytesSecMaxLength as defined in libvirt/libvirt-domain.h:4395
+	DomainTunableBlkdevTotalBytesSecMaxLength = "blkdeviotune.total_bytes_sec_max_length"
+	// DomainTunableBlkdevReadBytesSecMaxLength as defined in libvirt/libvirt-domain.h:4404
+	DomainTunableBlkdevReadBytesSecMaxLength = "blkdeviotune.read_bytes_sec_max_length"
+	// DomainTunableBlkdevWriteBytesSecMaxLength as defined in libvirt/libvirt-domain.h:4413
+	DomainTunableBlkdevWriteBytesSecMaxLength = "blkdeviotune.write_bytes_sec_max_length"
+	// DomainTunableBlkdevTotalIopsSecMaxLength as defined in libvirt/libvirt-domain.h:4422
+	DomainTunableBlkdevTotalIopsSecMaxLength = "blkdeviotune.total_iops_sec_max_length"
+	// DomainTunableBlkdevReadIopsSecMaxLength as defined in libvirt/libvirt-domain.h:4431
+	DomainTunableBlkdevReadIopsSecMaxLength = "blkdeviotune.read_iops_sec_max_length"
+	// DomainTunableBlkdevWriteIopsSecMaxLength as defined in libvirt/libvirt-domain.h:4440
+	DomainTunableBlkdevWriteIopsSecMaxLength = "blkdeviotune.write_iops_sec_max_length"
+	// DomainSchedFieldLength as defined in libvirt/libvirt-domain.h:4728
+	DomainSchedFieldLength = 80
+	// DomainBlkioFieldLength as defined in libvirt/libvirt-domain.h:4772
+	DomainBlkioFieldLength = 80
+	// DomainMemoryFieldLength as defined in libvirt/libvirt-domain.h:4816
+	DomainMemoryFieldLength = 80
+	// DomainLaunchSecuritySevMeasurement as defined in libvirt/libvirt-domain.h:4942
+	DomainLaunchSecuritySevMeasurement = "sev-measurement"
+	// NetworkPortBandwidthInAverage as defined in libvirt/libvirt-network.h:391
+	NetworkPortBandwidthInAverage = "inbound.average"
+	// NetworkPortBandwidthInPeak as defined in libvirt/libvirt-network.h:398
+	NetworkPortBandwidthInPeak = "inbound.peak"
+	// NetworkPortBandwidthInBurst as defined in libvirt/libvirt-network.h:405
+	NetworkPortBandwidthInBurst = "inbound.burst"
+	// NetworkPortBandwidthInFloor as defined in libvirt/libvirt-network.h:412
+	NetworkPortBandwidthInFloor = "inbound.floor"
+	// NetworkPortBandwidthOutAverage as defined in libvirt/libvirt-network.h:419
+	NetworkPortBandwidthOutAverage = "outbound.average"
+	// NetworkPortBandwidthOutPeak as defined in libvirt/libvirt-network.h:426
+	NetworkPortBandwidthOutPeak = "outbound.peak"
+	// NetworkPortBandwidthOutBurst as defined in libvirt/libvirt-network.h:433
+	NetworkPortBandwidthOutBurst = "outbound.burst"
+)
+
+// ConnectCloseReason as declared in libvirt/libvirt-common.h:119
+type ConnectCloseReason int32
+
+// ConnectCloseReason enumeration from libvirt/libvirt-common.h:119
+const (
+	ConnectCloseReasonError     ConnectCloseReason = iota
+	ConnectCloseReasonEOF       ConnectCloseReason = 1
+	ConnectCloseReasonKeepalive ConnectCloseReason = 2
+	ConnectCloseReasonClient    ConnectCloseReason = 3
+)
+
+// TypedParameterType as declared in libvirt/libvirt-common.h:138
+type TypedParameterType int32
+
+// TypedParameterType enumeration from libvirt/libvirt-common.h:138
+const (
+	TypedParamInt     TypedParameterType = 1
+	TypedParamUint    TypedParameterType = 2
+	TypedParamLlong   TypedParameterType = 3
+	TypedParamUllong  TypedParameterType = 4
+	TypedParamDouble  TypedParameterType = 5
+	TypedParamBoolean TypedParameterType = 6
+	TypedParamString  TypedParameterType = 7
+)
+
+// TypedParameterFlags as declared in libvirt/libvirt-common.h:163
+type TypedParameterFlags int32
+
+// TypedParameterFlags enumeration from libvirt/libvirt-common.h:163
+const (
+	TypedParamStringOkay TypedParameterFlags = 4
+)
+
+// NodeSuspendTarget as declared in libvirt/libvirt-host.h:61
+type NodeSuspendTarget int32
+
+// NodeSuspendTarget enumeration from libvirt/libvirt-host.h:61
+const (
+	NodeSuspendTargetMem    NodeSuspendTarget = iota
+	NodeSuspendTargetDisk   NodeSuspendTarget = 1
+	NodeSuspendTargetHybrid NodeSuspendTarget = 2
+)
+
+// NodeGetCPUStatsAllCPUs as declared in libvirt/libvirt-host.h:189
+type NodeGetCPUStatsAllCPUs int32
+
+// NodeGetCPUStatsAllCPUs enumeration from libvirt/libvirt-host.h:189
+const (
+	NodeCPUStatsAllCpus NodeGetCPUStatsAllCPUs = -1
+)
+
+// NodeGetMemoryStatsAllCells as declared in libvirt/libvirt-host.h:267
+type NodeGetMemoryStatsAllCells int32
+
+// NodeGetMemoryStatsAllCells enumeration from libvirt/libvirt-host.h:267
+const (
+	NodeMemoryStatsAllCells NodeGetMemoryStatsAllCells = -1
+)
+
+// ConnectFlags as declared in libvirt/libvirt-host.h:488
+type ConnectFlags int32
+
+// ConnectFlags enumeration from libvirt/libvirt-host.h:488
+const (
+	ConnectRo        ConnectFlags = 1
+	ConnectNoAliases ConnectFlags = 2
+)
+
+// ConnectCredentialType as declared in libvirt/libvirt-host.h:505
+type ConnectCredentialType int32
+
+// ConnectCredentialType enumeration from libvirt/libvirt-host.h:505
+const (
+	CredUsername     ConnectCredentialType = 1
+	CredAuthname     ConnectCredentialType = 2
+	CredLanguage     ConnectCredentialType = 3
+	CredCnonce       ConnectCredentialType = 4
+	CredPassphrase   ConnectCredentialType = 5
+	CredEchoprompt   ConnectCredentialType = 6
+	CredNoechoprompt ConnectCredentialType = 7
+	CredRealm        ConnectCredentialType = 8
+	CredExternal     ConnectCredentialType = 9
+)
+
+// CPUCompareResult as declared in libvirt/libvirt-host.h:752
+type CPUCompareResult int32
+
+// CPUCompareResult enumeration from libvirt/libvirt-host.h:752
+const (
+	CPUCompareError        CPUCompareResult = -1
+	CPUCompareIncompatible CPUCompareResult = 0
+	CPUCompareIdentical    CPUCompareResult = 1
+	CPUCompareSuperset     CPUCompareResult = 2
+)
+
+// ConnectCompareCPUFlags as declared in libvirt/libvirt-host.h:757
+type ConnectCompareCPUFlags int32
+
+// ConnectCompareCPUFlags enumeration from libvirt/libvirt-host.h:757
+const (
+	ConnectCompareCPUFailIncompatible ConnectCompareCPUFlags = 1
+)
+
+// ConnectBaselineCPUFlags as declared in libvirt/libvirt-host.h:783
+type ConnectBaselineCPUFlags int32
+
+// ConnectBaselineCPUFlags enumeration from libvirt/libvirt-host.h:783
+const (
+	ConnectBaselineCPUExpandFeatures ConnectBaselineCPUFlags = 1
+	ConnectBaselineCPUMigratable     ConnectBaselineCPUFlags = 2
+)
+
+// NodeAllocPagesFlags as declared in libvirt/libvirt-host.h:813
+type NodeAllocPagesFlags int32
+
+// NodeAllocPagesFlags enumeration from libvirt/libvirt-host.h:813
+const (
+	NodeAllocPagesAdd NodeAllocPagesFlags = iota
+	NodeAllocPagesSet NodeAllocPagesFlags = 1
+)
+
+// DomainState as declared in libvirt/libvirt-domain.h:70
+type DomainState int32
+
+// DomainState enumeration from libvirt/libvirt-domain.h:70
+const (
+	DomainNostate     DomainState = iota
+	DomainRunning     DomainState = 1
+	DomainBlocked     DomainState = 2
+	DomainPaused      DomainState = 3
+	DomainShutdown    DomainState = 4
+	DomainShutoff     DomainState = 5
+	DomainCrashed     DomainState = 6
+	DomainPmsuspended DomainState = 7
+)
+
+// DomainNostateReason as declared in libvirt/libvirt-domain.h:78
+type DomainNostateReason int32
+
+// DomainNostateReason enumeration from libvirt/libvirt-domain.h:78
+const (
+	DomainNostateUnknown DomainNostateReason = iota
+)
+
+// DomainRunningReason as declared in libvirt/libvirt-domain.h:97
+type DomainRunningReason int32
+
+// DomainRunningReason enumeration from libvirt/libvirt-domain.h:97
+const (
+	DomainRunningUnknown           DomainRunningReason = iota
+	DomainRunningBooted            DomainRunningReason = 1
+	DomainRunningMigrated          DomainRunningReason = 2
+	DomainRunningRestored          DomainRunningReason = 3
+	DomainRunningFromSnapshot      DomainRunningReason = 4
+	DomainRunningUnpaused          DomainRunningReason = 5
+	DomainRunningMigrationCanceled DomainRunningReason = 6
+	DomainRunningSaveCanceled      DomainRunningReason = 7
+	DomainRunningWakeup            DomainRunningReason = 8
+	DomainRunningCrashed           DomainRunningReason = 9
+	DomainRunningPostcopy          DomainRunningReason = 10
+)
+
+// DomainBlockedReason as declared in libvirt/libvirt-domain.h:105
+type DomainBlockedReason int32
+
+// DomainBlockedReason enumeration from libvirt/libvirt-domain.h:105
+const (
+	DomainBlockedUnknown DomainBlockedReason = iota
+)
+
+// DomainPausedReason as declared in libvirt/libvirt-domain.h:126
+type DomainPausedReason int32
+
+// DomainPausedReason enumeration from libvirt/libvirt-domain.h:126
+const (
+	DomainPausedUnknown        DomainPausedReason = iota
+	DomainPausedUser           DomainPausedReason = 1
+	DomainPausedMigration      DomainPausedReason = 2
+	DomainPausedSave           DomainPausedReason = 3
+	DomainPausedDump           DomainPausedReason = 4
+	DomainPausedIoerror        DomainPausedReason = 5
+	DomainPausedWatchdog       DomainPausedReason = 6
+	DomainPausedFromSnapshot   DomainPausedReason = 7
+	DomainPausedShuttingDown   DomainPausedReason = 8
+	DomainPausedSnapshot       DomainPausedReason = 9
+	DomainPausedCrashed        DomainPausedReason = 10
+	DomainPausedStartingUp     DomainPausedReason = 11
+	DomainPausedPostcopy       DomainPausedReason = 12
+	DomainPausedPostcopyFailed DomainPausedReason = 13
+)
+
+// DomainShutdownReason as declared in libvirt/libvirt-domain.h:135
+type DomainShutdownReason int32
+
+// DomainShutdownReason enumeration from libvirt/libvirt-domain.h:135
+const (
+	DomainShutdownUnknown DomainShutdownReason = iota
+	DomainShutdownUser    DomainShutdownReason = 1
+)
+
+// DomainShutoffReason as declared in libvirt/libvirt-domain.h:152
+type DomainShutoffReason int32
+
+// DomainShutoffReason enumeration from libvirt/libvirt-domain.h:152
+const (
+	DomainShutoffUnknown      DomainShutoffReason = iota
+	DomainShutoffShutdown     DomainShutoffReason = 1
+	DomainShutoffDestroyed    DomainShutoffReason = 2
+	DomainShutoffCrashed      DomainShutoffReason = 3
+	DomainShutoffMigrated     DomainShutoffReason = 4
+	DomainShutoffSaved        DomainShutoffReason = 5
+	DomainShutoffFailed       DomainShutoffReason = 6
+	DomainShutoffFromSnapshot DomainShutoffReason = 7
+	DomainShutoffDaemon       DomainShutoffReason = 8
+)
+
+// DomainCrashedReason as declared in libvirt/libvirt-domain.h:161
+type DomainCrashedReason int32
+
+// DomainCrashedReason enumeration from libvirt/libvirt-domain.h:161
+const (
+	DomainCrashedUnknown  DomainCrashedReason = iota
+	DomainCrashedPanicked DomainCrashedReason = 1
+)
+
+// DomainPMSuspendedReason as declared in libvirt/libvirt-domain.h:169
+type DomainPMSuspendedReason int32
+
+// DomainPMSuspendedReason enumeration from libvirt/libvirt-domain.h:169
+const (
+	DomainPmsuspendedUnknown DomainPMSuspendedReason = iota
+)
+
+// DomainPMSuspendedDiskReason as declared in libvirt/libvirt-domain.h:177
+type DomainPMSuspendedDiskReason int32
+
+// DomainPMSuspendedDiskReason enumeration from libvirt/libvirt-domain.h:177
+const (
+	DomainPmsuspendedDiskUnknown DomainPMSuspendedDiskReason = iota
+)
+
+// DomainControlState as declared in libvirt/libvirt-domain.h:197
+type DomainControlState int32
+
+// DomainControlState enumeration from libvirt/libvirt-domain.h:197
+const (
+	DomainControlOk       DomainControlState = iota
+	DomainControlJob      DomainControlState = 1
+	DomainControlOccupied DomainControlState = 2
+	DomainControlError    DomainControlState = 3
+)
+
+// DomainControlErrorReason as declared in libvirt/libvirt-domain.h:217
+type DomainControlErrorReason int32
+
+// DomainControlErrorReason enumeration from libvirt/libvirt-domain.h:217
+const (
+	DomainControlErrorReasonNone     DomainControlErrorReason = iota
+	DomainControlErrorReasonUnknown  DomainControlErrorReason = 1
+	DomainControlErrorReasonMonitor  DomainControlErrorReason = 2
+	DomainControlErrorReasonInternal DomainControlErrorReason = 3
+)
+
+// DomainModificationImpact as declared in libvirt/libvirt-domain.h:265
+type DomainModificationImpact int32
+
+// DomainModificationImpact enumeration from libvirt/libvirt-domain.h:265
+const (
+	DomainAffectCurrent DomainModificationImpact = iota
+	DomainAffectLive    DomainModificationImpact = 1
+	DomainAffectConfig  DomainModificationImpact = 2
+)
+
+// DomainCreateFlags as declared in libvirt/libvirt-domain.h:305
+type DomainCreateFlags int32
+
+// DomainCreateFlags enumeration from libvirt/libvirt-domain.h:305
+const (
+	DomainNone             DomainCreateFlags = iota
+	DomainStartPaused      DomainCreateFlags = 1
+	DomainStartAutodestroy DomainCreateFlags = 2
+	DomainStartBypassCache DomainCreateFlags = 4
+	DomainStartForceBoot   DomainCreateFlags = 8
+	DomainStartValidate    DomainCreateFlags = 16
+)
+
+// DomainMemoryStatTags as declared in libvirt/libvirt-domain.h:660
+type DomainMemoryStatTags int32
+
+// DomainMemoryStatTags enumeration from libvirt/libvirt-domain.h:660
+const (
+	DomainMemoryStatSwapIn         DomainMemoryStatTags = iota
+	DomainMemoryStatSwapOut        DomainMemoryStatTags = 1
+	DomainMemoryStatMajorFault     DomainMemoryStatTags = 2
+	DomainMemoryStatMinorFault     DomainMemoryStatTags = 3
+	DomainMemoryStatUnused         DomainMemoryStatTags = 4
+	DomainMemoryStatAvailable      DomainMemoryStatTags = 5
+	DomainMemoryStatActualBalloon  DomainMemoryStatTags = 6
+	DomainMemoryStatRss            DomainMemoryStatTags = 7
+	DomainMemoryStatUsable         DomainMemoryStatTags = 8
+	DomainMemoryStatLastUpdate     DomainMemoryStatTags = 9
+	DomainMemoryStatDiskCaches     DomainMemoryStatTags = 10
+	DomainMemoryStatHugetlbPgalloc DomainMemoryStatTags = 11
+	DomainMemoryStatHugetlbPgfail  DomainMemoryStatTags = 12
+	DomainMemoryStatNr             DomainMemoryStatTags = 13
+)
+
+// DomainCoreDumpFlags as declared in libvirt/libvirt-domain.h:679
+type DomainCoreDumpFlags int32
+
+// DomainCoreDumpFlags enumeration from libvirt/libvirt-domain.h:679
+const (
+	DumpCrash       DomainCoreDumpFlags = 1
+	DumpLive        DomainCoreDumpFlags = 2
+	DumpBypassCache DomainCoreDumpFlags = 4
+	DumpReset       DomainCoreDumpFlags = 8
+	DumpMemoryOnly  DomainCoreDumpFlags = 16
+)
+
+// DomainCoreDumpFormat as declared in libvirt/libvirt-domain.h:702
+type DomainCoreDumpFormat int32
+
+// DomainCoreDumpFormat enumeration from libvirt/libvirt-domain.h:702
+const (
+	DomainCoreDumpFormatRaw         DomainCoreDumpFormat = iota
+	DomainCoreDumpFormatKdumpZlib   DomainCoreDumpFormat = 1
+	DomainCoreDumpFormatKdumpLzo    DomainCoreDumpFormat = 2
+	DomainCoreDumpFormatKdumpSnappy DomainCoreDumpFormat = 3
+)
+
+// DomainMigrateFlags as declared in libvirt/libvirt-domain.h:852
+type DomainMigrateFlags int32
+
+// DomainMigrateFlags enumeration from libvirt/libvirt-domain.h:852
+const (
+	MigrateLive             DomainMigrateFlags = 1
+	MigratePeer2peer        DomainMigrateFlags = 2
+	MigrateTunnelled        DomainMigrateFlags = 4
+	MigratePersistDest      DomainMigrateFlags = 8
+	MigrateUndefineSource   DomainMigrateFlags = 16
+	MigratePaused           DomainMigrateFlags = 32
+	MigrateNonSharedDisk    DomainMigrateFlags = 64
+	MigrateNonSharedInc     DomainMigrateFlags = 128
+	MigrateChangeProtection DomainMigrateFlags = 256
+	MigrateUnsafe           DomainMigrateFlags = 512
+	MigrateOffline          DomainMigrateFlags = 1024
+	MigrateCompressed       DomainMigrateFlags = 2048
+	MigrateAbortOnError     DomainMigrateFlags = 4096
+	MigrateAutoConverge     DomainMigrateFlags = 8192
+	MigrateRdmaPinAll       DomainMigrateFlags = 16384
+	MigratePostcopy         DomainMigrateFlags = 32768
+	MigrateTLS              DomainMigrateFlags = 65536
+	MigrateParallel         DomainMigrateFlags = 131072
+)
+
+// DomainMigrateMaxSpeedFlags as declared in libvirt/libvirt-domain.h:1118
+type DomainMigrateMaxSpeedFlags int32
+
+// DomainMigrateMaxSpeedFlags enumeration from libvirt/libvirt-domain.h:1118
+const (
+	DomainMigrateMaxSpeedPostcopy DomainMigrateMaxSpeedFlags = 1
+)
+
+// DomainShutdownFlagValues as declared in libvirt/libvirt-domain.h:1184
+type DomainShutdownFlagValues int32
+
+// DomainShutdownFlagValues enumeration from libvirt/libvirt-domain.h:1184
+const (
+	DomainShutdownDefault      DomainShutdownFlagValues = iota
+	DomainShutdownAcpiPowerBtn DomainShutdownFlagValues = 1
+	DomainShutdownGuestAgent   DomainShutdownFlagValues = 2
+	DomainShutdownInitctl      DomainShutdownFlagValues = 4
+	DomainShutdownSignal       DomainShutdownFlagValues = 8
+	DomainShutdownParavirt     DomainShutdownFlagValues = 16
+)
+
+// DomainRebootFlagValues as declared in libvirt/libvirt-domain.h:1197
+type DomainRebootFlagValues int32
+
+// DomainRebootFlagValues enumeration from libvirt/libvirt-domain.h:1197
+const (
+	DomainRebootDefault      DomainRebootFlagValues = iota
+	DomainRebootAcpiPowerBtn DomainRebootFlagValues = 1
+	DomainRebootGuestAgent   DomainRebootFlagValues = 2
+	DomainRebootInitctl      DomainRebootFlagValues = 4
+	DomainRebootSignal       DomainRebootFlagValues = 8
+	DomainRebootParavirt     DomainRebootFlagValues = 16
+)
+
+// DomainDestroyFlagsValues as declared in libvirt/libvirt-domain.h:1215
+type DomainDestroyFlagsValues int32
+
+// DomainDestroyFlagsValues enumeration from libvirt/libvirt-domain.h:1215
+const (
+	DomainDestroyDefault  DomainDestroyFlagsValues = iota
+	DomainDestroyGraceful DomainDestroyFlagsValues = 1
+)
+
+// DomainSaveRestoreFlags as declared in libvirt/libvirt-domain.h:1247
+type DomainSaveRestoreFlags int32
+
+// DomainSaveRestoreFlags enumeration from libvirt/libvirt-domain.h:1247
+const (
+	DomainSaveBypassCache DomainSaveRestoreFlags = 1
+	DomainSaveRunning     DomainSaveRestoreFlags = 2
+	DomainSavePaused      DomainSaveRestoreFlags = 4
+)
+
+// DomainMemoryModFlags as declared in libvirt/libvirt-domain.h:1503
+type DomainMemoryModFlags int32
+
+// DomainMemoryModFlags enumeration from libvirt/libvirt-domain.h:1503
+const (
+	DomainMemCurrent DomainMemoryModFlags = iota
+	DomainMemLive    DomainMemoryModFlags = 1
+	DomainMemConfig  DomainMemoryModFlags = 2
+	DomainMemMaximum DomainMemoryModFlags = 4
+)
+
+// DomainNumatuneMemMode as declared in libvirt/libvirt-domain.h:1521
+type DomainNumatuneMemMode int32
+
+// DomainNumatuneMemMode enumeration from libvirt/libvirt-domain.h:1521
+const (
+	DomainNumatuneMemStrict     DomainNumatuneMemMode = iota
+	DomainNumatuneMemPreferred  DomainNumatuneMemMode = 1
+	DomainNumatuneMemInterleave DomainNumatuneMemMode = 2
+)
+
+// DomainMetadataType as declared in libvirt/libvirt-domain.h:1583
+type DomainMetadataType int32
+
+// DomainMetadataType enumeration from libvirt/libvirt-domain.h:1583
+const (
+	DomainMetadataDescription DomainMetadataType = iota
+	DomainMetadataTitle       DomainMetadataType = 1
+	DomainMetadataElement     DomainMetadataType = 2
+)
+
+// DomainXMLFlags as declared in libvirt/libvirt-domain.h:1613
+type DomainXMLFlags int32
+
+// DomainXMLFlags enumeration from libvirt/libvirt-domain.h:1613
+const (
+	DomainXMLSecure     DomainXMLFlags = 1
+	DomainXMLInactive   DomainXMLFlags = 2
+	DomainXMLUpdateCPU  DomainXMLFlags = 4
+	DomainXMLMigratable DomainXMLFlags = 8
+)
+
+// DomainSaveImageXMLFlags as declared in libvirt/libvirt-domain.h:1617
+type DomainSaveImageXMLFlags int32
+
+// DomainSaveImageXMLFlags enumeration from libvirt/libvirt-domain.h:1617
+const (
+	DomainSaveImageXMLSecure DomainSaveImageXMLFlags = 1
+)
+
+// DomainBlockResizeFlags as declared in libvirt/libvirt-domain.h:1722
+type DomainBlockResizeFlags int32
+
+// DomainBlockResizeFlags enumeration from libvirt/libvirt-domain.h:1722
+const (
+	DomainBlockResizeBytes DomainBlockResizeFlags = 1
+)
+
+// DomainMemoryFlags as declared in libvirt/libvirt-domain.h:1785
+type DomainMemoryFlags int32
+
+// DomainMemoryFlags enumeration from libvirt/libvirt-domain.h:1785
+const (
+	MemoryVirtual  DomainMemoryFlags = 1
+	MemoryPhysical DomainMemoryFlags = 2
+)
+
+// DomainDefineFlags as declared in libvirt/libvirt-domain.h:1795
+type DomainDefineFlags int32
+
+// DomainDefineFlags enumeration from libvirt/libvirt-domain.h:1795
+const (
+	DomainDefineValidate DomainDefineFlags = 1
+)
+
+// DomainUndefineFlagsValues as declared in libvirt/libvirt-domain.h:1822
+type DomainUndefineFlagsValues int32
+
+// DomainUndefineFlagsValues enumeration from libvirt/libvirt-domain.h:1822
+const (
+	DomainUndefineManagedSave         DomainUndefineFlagsValues = 1
+	DomainUndefineSnapshotsMetadata   DomainUndefineFlagsValues = 2
+	DomainUndefineNvram               DomainUndefineFlagsValues = 4
+	DomainUndefineKeepNvram           DomainUndefineFlagsValues = 8
+	DomainUndefineCheckpointsMetadata DomainUndefineFlagsValues = 16
+)
+
+// ConnectListAllDomainsFlags as declared in libvirt/libvirt-domain.h:1861
+type ConnectListAllDomainsFlags int32
+
+// ConnectListAllDomainsFlags enumeration from libvirt/libvirt-domain.h:1861
+const (
+	ConnectListDomainsActive        ConnectListAllDomainsFlags = 1
+	ConnectListDomainsInactive      ConnectListAllDomainsFlags = 2
+	ConnectListDomainsPersistent    ConnectListAllDomainsFlags = 4
+	ConnectListDomainsTransient     ConnectListAllDomainsFlags = 8
+	ConnectListDomainsRunning       ConnectListAllDomainsFlags = 16
+	ConnectListDomainsPaused        ConnectListAllDomainsFlags = 32
+	ConnectListDomainsShutoff       ConnectListAllDomainsFlags = 64
+	ConnectListDomainsOther         ConnectListAllDomainsFlags = 128
+	ConnectListDomainsManagedsave   ConnectListAllDomainsFlags = 256
+	ConnectListDomainsNoManagedsave ConnectListAllDomainsFlags = 512
+	ConnectListDomainsAutostart     ConnectListAllDomainsFlags = 1024
+	ConnectListDomainsNoAutostart   ConnectListAllDomainsFlags = 2048
+	ConnectListDomainsHasSnapshot   ConnectListAllDomainsFlags = 4096
+	ConnectListDomainsNoSnapshot    ConnectListAllDomainsFlags = 8192
+	ConnectListDomainsHasCheckpoint ConnectListAllDomainsFlags = 16384
+	ConnectListDomainsNoCheckpoint  ConnectListAllDomainsFlags = 32768
+)
+
+// VCPUState as declared in libvirt/libvirt-domain.h:1892
+type VCPUState int32
+
+// VCPUState enumeration from libvirt/libvirt-domain.h:1892
+const (
+	VCPUOffline VCPUState = iota
+	VCPURunning VCPUState = 1
+	VCPUBlocked VCPUState = 2
+)
+
+// DomainVCPUFlags as declared in libvirt/libvirt-domain.h:1914
+type DomainVCPUFlags int32
+
+// DomainVCPUFlags enumeration from libvirt/libvirt-domain.h:1914
+const (
+	DomainVCPUCurrent      DomainVCPUFlags = iota
+	DomainVCPULive         DomainVCPUFlags = 1
+	DomainVCPUConfig       DomainVCPUFlags = 2
+	DomainVCPUMaximum      DomainVCPUFlags = 4
+	DomainVCPUGuest        DomainVCPUFlags = 8
+	DomainVCPUHotpluggable DomainVCPUFlags = 16
+)
+
+// DomainDeviceModifyFlags as declared in libvirt/libvirt-domain.h:2131
+type DomainDeviceModifyFlags int32
+
+// DomainDeviceModifyFlags enumeration from libvirt/libvirt-domain.h:2131
+const (
+	DomainDeviceModifyCurrent DomainDeviceModifyFlags = iota
+	DomainDeviceModifyLive    DomainDeviceModifyFlags = 1
+	DomainDeviceModifyConfig  DomainDeviceModifyFlags = 2
+	DomainDeviceModifyForce   DomainDeviceModifyFlags = 4
+)
+
+// DomainStatsTypes as declared in libvirt/libvirt-domain.h:2164
+type DomainStatsTypes int32
+
+// DomainStatsTypes enumeration from libvirt/libvirt-domain.h:2164
+const (
+	DomainStatsState     DomainStatsTypes = 1
+	DomainStatsCPUTotal  DomainStatsTypes = 2
+	DomainStatsBalloon   DomainStatsTypes = 4
+	DomainStatsVCPU      DomainStatsTypes = 8
+	DomainStatsInterface DomainStatsTypes = 16
+	DomainStatsBlock     DomainStatsTypes = 32
+	DomainStatsPerf      DomainStatsTypes = 64
+	DomainStatsIothread  DomainStatsTypes = 128
+	DomainStatsMemory    DomainStatsTypes = 256
+)
+
+// ConnectGetAllDomainStatsFlags as declared in libvirt/libvirt-domain.h:2182
+type ConnectGetAllDomainStatsFlags int32
+
+// ConnectGetAllDomainStatsFlags enumeration from libvirt/libvirt-domain.h:2182
+const (
+	ConnectGetAllDomainsStatsActive       ConnectGetAllDomainStatsFlags = 1
+	ConnectGetAllDomainsStatsInactive     ConnectGetAllDomainStatsFlags = 2
+	ConnectGetAllDomainsStatsPersistent   ConnectGetAllDomainStatsFlags = 4
+	ConnectGetAllDomainsStatsTransient    ConnectGetAllDomainStatsFlags = 8
+	ConnectGetAllDomainsStatsRunning      ConnectGetAllDomainStatsFlags = 16
+	ConnectGetAllDomainsStatsPaused       ConnectGetAllDomainStatsFlags = 32
+	ConnectGetAllDomainsStatsShutoff      ConnectGetAllDomainStatsFlags = 64
+	ConnectGetAllDomainsStatsOther        ConnectGetAllDomainStatsFlags = 128
+	ConnectGetAllDomainsStatsNowait       ConnectGetAllDomainStatsFlags = 536870912
+	ConnectGetAllDomainsStatsBacking      ConnectGetAllDomainStatsFlags = 1073741824
+	ConnectGetAllDomainsStatsEnforceStats ConnectGetAllDomainStatsFlags = -2147483648
+)
+
+// DomainBlockJobType as declared in libvirt/libvirt-domain.h:2470
+type DomainBlockJobType int32
+
+// DomainBlockJobType enumeration from libvirt/libvirt-domain.h:2470
+const (
+	DomainBlockJobTypeUnknown      DomainBlockJobType = iota
+	DomainBlockJobTypePull         DomainBlockJobType = 1
+	DomainBlockJobTypeCopy         DomainBlockJobType = 2
+	DomainBlockJobTypeCommit       DomainBlockJobType = 3
+	DomainBlockJobTypeActiveCommit DomainBlockJobType = 4
+	DomainBlockJobTypeBackup       DomainBlockJobType = 5
+)
+
+// DomainBlockJobAbortFlags as declared in libvirt/libvirt-domain.h:2482
+type DomainBlockJobAbortFlags int32
+
+// DomainBlockJobAbortFlags enumeration from libvirt/libvirt-domain.h:2482
+const (
+	DomainBlockJobAbortAsync DomainBlockJobAbortFlags = 1
+	DomainBlockJobAbortPivot DomainBlockJobAbortFlags = 2
+)
+
+// DomainBlockJobInfoFlags as declared in libvirt/libvirt-domain.h:2491
+type DomainBlockJobInfoFlags int32
+
+// DomainBlockJobInfoFlags enumeration from libvirt/libvirt-domain.h:2491
+const (
+	DomainBlockJobInfoBandwidthBytes DomainBlockJobInfoFlags = 1
+)
+
+// DomainBlockJobSetSpeedFlags as declared in libvirt/libvirt-domain.h:2520
+type DomainBlockJobSetSpeedFlags int32
+
+// DomainBlockJobSetSpeedFlags enumeration from libvirt/libvirt-domain.h:2520
+const (
+	DomainBlockJobSpeedBandwidthBytes DomainBlockJobSetSpeedFlags = 1
+)
+
+// DomainBlockPullFlags as declared in libvirt/libvirt-domain.h:2530
+type DomainBlockPullFlags int32
+
+// DomainBlockPullFlags enumeration from libvirt/libvirt-domain.h:2530
+const (
+	DomainBlockPullBandwidthBytes DomainBlockPullFlags = 64
+)
+
+// DomainBlockRebaseFlags as declared in libvirt/libvirt-domain.h:2554
+type DomainBlockRebaseFlags int32
+
+// DomainBlockRebaseFlags enumeration from libvirt/libvirt-domain.h:2554
+const (
+	DomainBlockRebaseShallow        DomainBlockRebaseFlags = 1
+	DomainBlockRebaseReuseExt       DomainBlockRebaseFlags = 2
+	DomainBlockRebaseCopyRaw        DomainBlockRebaseFlags = 4
+	DomainBlockRebaseCopy           DomainBlockRebaseFlags = 8
+	DomainBlockRebaseRelative       DomainBlockRebaseFlags = 16
+	DomainBlockRebaseCopyDev        DomainBlockRebaseFlags = 32
+	DomainBlockRebaseBandwidthBytes DomainBlockRebaseFlags = 64
+)
+
+// DomainBlockCopyFlags as declared in libvirt/libvirt-domain.h:2573
+type DomainBlockCopyFlags int32
+
+// DomainBlockCopyFlags enumeration from libvirt/libvirt-domain.h:2573
+const (
+	DomainBlockCopyShallow      DomainBlockCopyFlags = 1
+	DomainBlockCopyReuseExt     DomainBlockCopyFlags = 2
+	DomainBlockCopyTransientJob DomainBlockCopyFlags = 4
+)
+
+// DomainBlockCommitFlags as declared in libvirt/libvirt-domain.h:2638
+type DomainBlockCommitFlags int32
+
+// DomainBlockCommitFlags enumeration from libvirt/libvirt-domain.h:2638
+const (
+	DomainBlockCommitShallow        DomainBlockCommitFlags = 1
+	DomainBlockCommitDelete         DomainBlockCommitFlags = 2
+	DomainBlockCommitActive         DomainBlockCommitFlags = 4
+	DomainBlockCommitRelative       DomainBlockCommitFlags = 8
+	DomainBlockCommitBandwidthBytes DomainBlockCommitFlags = 16
+)
+
+// DomainDiskErrorCode as declared in libvirt/libvirt-domain.h:2829
+type DomainDiskErrorCode int32
+
+// DomainDiskErrorCode enumeration from libvirt/libvirt-domain.h:2829
+const (
+	DomainDiskErrorNone    DomainDiskErrorCode = iota
+	DomainDiskErrorUnspec  DomainDiskErrorCode = 1
+	DomainDiskErrorNoSpace DomainDiskErrorCode = 2
+)
+
+// KeycodeSet as declared in libvirt/libvirt-domain.h:2875
+type KeycodeSet int32
+
+// KeycodeSet enumeration from libvirt/libvirt-domain.h:2875
+const (
+	KeycodeSetLinux  KeycodeSet = iota
+	KeycodeSetXt     KeycodeSet = 1
+	KeycodeSetAtset1 KeycodeSet = 2
+	KeycodeSetAtset2 KeycodeSet = 3
+	KeycodeSetAtset3 KeycodeSet = 4
+	KeycodeSetOsx    KeycodeSet = 5
+	KeycodeSetXtKbd  KeycodeSet = 6
+	KeycodeSetUsb    KeycodeSet = 7
+	KeycodeSetWin32  KeycodeSet = 8
+	KeycodeSetQnum   KeycodeSet = 9
+)
+
+// DomainProcessSignal as declared in libvirt/libvirt-domain.h:2984
+type DomainProcessSignal int32
+
+// DomainProcessSignal enumeration from libvirt/libvirt-domain.h:2984
+const (
+	DomainProcessSignalNop    DomainProcessSignal = iota
+	DomainProcessSignalHup    DomainProcessSignal = 1
+	DomainProcessSignalInt    DomainProcessSignal = 2
+	DomainProcessSignalQuit   DomainProcessSignal = 3
+	DomainProcessSignalIll    DomainProcessSignal = 4
+	DomainProcessSignalTrap   DomainProcessSignal = 5
+	DomainProcessSignalAbrt   DomainProcessSignal = 6
+	DomainProcessSignalBus    DomainProcessSignal = 7
+	DomainProcessSignalFpe    DomainProcessSignal = 8
+	DomainProcessSignalKill   DomainProcessSignal = 9
+	DomainProcessSignalUsr1   DomainProcessSignal = 10
+	DomainProcessSignalSegv   DomainProcessSignal = 11
+	DomainProcessSignalUsr2   DomainProcessSignal = 12
+	DomainProcessSignalPipe   DomainProcessSignal = 13
+	DomainProcessSignalAlrm   DomainProcessSignal = 14
+	DomainProcessSignalTerm   DomainProcessSignal = 15
+	DomainProcessSignalStkflt DomainProcessSignal = 16
+	DomainProcessSignalChld   DomainProcessSignal = 17
+	DomainProcessSignalCont   DomainProcessSignal = 18
+	DomainProcessSignalStop   DomainProcessSignal = 19
+	DomainProcessSignalTstp   DomainProcessSignal = 20
+	DomainProcessSignalTtin   DomainProcessSignal = 21
+	DomainProcessSignalTtou   DomainProcessSignal = 22
+	DomainProcessSignalUrg    DomainProcessSignal = 23
+	DomainProcessSignalXcpu   DomainProcessSignal = 24
+	DomainProcessSignalXfsz   DomainProcessSignal = 25
+	DomainProcessSignalVtalrm DomainProcessSignal = 26
+	DomainProcessSignalProf   DomainProcessSignal = 27
+	DomainProcessSignalWinch  DomainProcessSignal = 28
+	DomainProcessSignalPoll   DomainProcessSignal = 29
+	DomainProcessSignalPwr    DomainProcessSignal = 30
+	DomainProcessSignalSys    DomainProcessSignal = 31
+	DomainProcessSignalRt0    DomainProcessSignal = 32
+	DomainProcessSignalRt1    DomainProcessSignal = 33
+	DomainProcessSignalRt2    DomainProcessSignal = 34
+	DomainProcessSignalRt3    DomainProcessSignal = 35
+	DomainProcessSignalRt4    DomainProcessSignal = 36
+	DomainProcessSignalRt5    DomainProcessSignal = 37
+	DomainProcessSignalRt6    DomainProcessSignal = 38
+	DomainProcessSignalRt7    DomainProcessSignal = 39
+	DomainProcessSignalRt8    DomainProcessSignal = 40
+	DomainProcessSignalRt9    DomainProcessSignal = 41
+	DomainProcessSignalRt10   DomainProcessSignal = 42
+	DomainProcessSignalRt11   DomainProcessSignal = 43
+	DomainProcessSignalRt12   DomainProcessSignal = 44
+	DomainProcessSignalRt13   DomainProcessSignal = 45
+	DomainProcessSignalRt14   DomainProcessSignal = 46
+	DomainProcessSignalRt15   DomainProcessSignal = 47
+	DomainProcessSignalRt16   DomainProcessSignal = 48
+	DomainProcessSignalRt17   DomainProcessSignal = 49
+	DomainProcessSignalRt18   DomainProcessSignal = 50
+	DomainProcessSignalRt19   DomainProcessSignal = 51
+	DomainProcessSignalRt20   DomainProcessSignal = 52
+	DomainProcessSignalRt21   DomainProcessSignal = 53
+	DomainProcessSignalRt22   DomainProcessSignal = 54
+	DomainProcessSignalRt23   DomainProcessSignal = 55
+	DomainProcessSignalRt24   DomainProcessSignal = 56
+	DomainProcessSignalRt25   DomainProcessSignal = 57
+	DomainProcessSignalRt26   DomainProcessSignal = 58
+	DomainProcessSignalRt27   DomainProcessSignal = 59
+	DomainProcessSignalRt28   DomainProcessSignal = 60
+	DomainProcessSignalRt29   DomainProcessSignal = 61
+	DomainProcessSignalRt30   DomainProcessSignal = 62
+	DomainProcessSignalRt31   DomainProcessSignal = 63
+	DomainProcessSignalRt32   DomainProcessSignal = 64
+)
+
+// DomainEventType as declared in libvirt/libvirt-domain.h:3022
+type DomainEventType int32
+
+// DomainEventType enumeration from libvirt/libvirt-domain.h:3022
+const (
+	DomainEventDefined     DomainEventType = iota
+	DomainEventUndefined   DomainEventType = 1
+	DomainEventStarted     DomainEventType = 2
+	DomainEventSuspended   DomainEventType = 3
+	DomainEventResumed     DomainEventType = 4
+	DomainEventStopped     DomainEventType = 5
+	DomainEventShutdown    DomainEventType = 6
+	DomainEventPmsuspended DomainEventType = 7
+	DomainEventCrashed     DomainEventType = 8
+)
+
+// DomainEventDefinedDetailType as declared in libvirt/libvirt-domain.h:3038
+type DomainEventDefinedDetailType int32
+
+// DomainEventDefinedDetailType enumeration from libvirt/libvirt-domain.h:3038
+const (
+	DomainEventDefinedAdded        DomainEventDefinedDetailType = iota
+	DomainEventDefinedUpdated      DomainEventDefinedDetailType = 1
+	DomainEventDefinedRenamed      DomainEventDefinedDetailType = 2
+	DomainEventDefinedFromSnapshot DomainEventDefinedDetailType = 3
+)
+
+// DomainEventUndefinedDetailType as declared in libvirt/libvirt-domain.h:3052
+type DomainEventUndefinedDetailType int32
+
+// DomainEventUndefinedDetailType enumeration from libvirt/libvirt-domain.h:3052
+const (
+	DomainEventUndefinedRemoved DomainEventUndefinedDetailType = iota
+	DomainEventUndefinedRenamed DomainEventUndefinedDetailType = 1
+)
+
+// DomainEventStartedDetailType as declared in libvirt/libvirt-domain.h:3069
+type DomainEventStartedDetailType int32
+
+// DomainEventStartedDetailType enumeration from libvirt/libvirt-domain.h:3069
+const (
+	DomainEventStartedBooted       DomainEventStartedDetailType = iota
+	DomainEventStartedMigrated     DomainEventStartedDetailType = 1
+	DomainEventStartedRestored     DomainEventStartedDetailType = 2
+	DomainEventStartedFromSnapshot DomainEventStartedDetailType = 3
+	DomainEventStartedWakeup       DomainEventStartedDetailType = 4
+)
+
+// DomainEventSuspendedDetailType as declared in libvirt/libvirt-domain.h:3090
+type DomainEventSuspendedDetailType int32
+
+// DomainEventSuspendedDetailType enumeration from libvirt/libvirt-domain.h:3090
+const (
+	DomainEventSuspendedPaused         DomainEventSuspendedDetailType = iota
+	DomainEventSuspendedMigrated       DomainEventSuspendedDetailType = 1
+	DomainEventSuspendedIoerror        DomainEventSuspendedDetailType = 2
+	DomainEventSuspendedWatchdog       DomainEventSuspendedDetailType = 3
+	DomainEventSuspendedRestored       DomainEventSuspendedDetailType = 4
+	DomainEventSuspendedFromSnapshot   DomainEventSuspendedDetailType = 5
+	DomainEventSuspendedAPIError       DomainEventSuspendedDetailType = 6
+	DomainEventSuspendedPostcopy       DomainEventSuspendedDetailType = 7
+	DomainEventSuspendedPostcopyFailed DomainEventSuspendedDetailType = 8
+)
+
+// DomainEventResumedDetailType as declared in libvirt/libvirt-domain.h:3107
+type DomainEventResumedDetailType int32
+
+// DomainEventResumedDetailType enumeration from libvirt/libvirt-domain.h:3107
+const (
+	DomainEventResumedUnpaused     DomainEventResumedDetailType = iota
+	DomainEventResumedMigrated     DomainEventResumedDetailType = 1
+	DomainEventResumedFromSnapshot DomainEventResumedDetailType = 2
+	DomainEventResumedPostcopy     DomainEventResumedDetailType = 3
+)
+
+// DomainEventStoppedDetailType as declared in libvirt/libvirt-domain.h:3126
+type DomainEventStoppedDetailType int32
+
+// DomainEventStoppedDetailType enumeration from libvirt/libvirt-domain.h:3126
+const (
+	DomainEventStoppedShutdown     DomainEventStoppedDetailType = iota
+	DomainEventStoppedDestroyed    DomainEventStoppedDetailType = 1
+	DomainEventStoppedCrashed      DomainEventStoppedDetailType = 2
+	DomainEventStoppedMigrated     DomainEventStoppedDetailType = 3
+	DomainEventStoppedSaved        DomainEventStoppedDetailType = 4
+	DomainEventStoppedFailed       DomainEventStoppedDetailType = 5
+	DomainEventStoppedFromSnapshot DomainEventStoppedDetailType = 6
+)
+
+// DomainEventShutdownDetailType as declared in libvirt/libvirt-domain.h:3149
+type DomainEventShutdownDetailType int32
+
+// DomainEventShutdownDetailType enumeration from libvirt/libvirt-domain.h:3149
+const (
+	DomainEventShutdownFinished DomainEventShutdownDetailType = iota
+	DomainEventShutdownGuest    DomainEventShutdownDetailType = 1
+	DomainEventShutdownHost     DomainEventShutdownDetailType = 2
+)
+
+// DomainEventPMSuspendedDetailType as declared in libvirt/libvirt-domain.h:3163
+type DomainEventPMSuspendedDetailType int32
+
+// DomainEventPMSuspendedDetailType enumeration from libvirt/libvirt-domain.h:3163
+const (
+	DomainEventPmsuspendedMemory DomainEventPMSuspendedDetailType = iota
+	DomainEventPmsuspendedDisk   DomainEventPMSuspendedDetailType = 1
+)
+
+// DomainEventCrashedDetailType as declared in libvirt/libvirt-domain.h:3176
+type DomainEventCrashedDetailType int32
+
+// DomainEventCrashedDetailType enumeration from libvirt/libvirt-domain.h:3176
+const (
+	DomainEventCrashedPanicked DomainEventCrashedDetailType = iota
+)
+
+// DomainJobType as declared in libvirt/libvirt-domain.h:3220
+type DomainJobType int32
+
+// DomainJobType enumeration from libvirt/libvirt-domain.h:3220
+const (
+	DomainJobNone      DomainJobType = iota
+	DomainJobBounded   DomainJobType = 1
+	DomainJobUnbounded DomainJobType = 2
+	DomainJobCompleted DomainJobType = 3
+	DomainJobFailed    DomainJobType = 4
+	DomainJobCancelled DomainJobType = 5
+)
+
+// DomainGetJobStatsFlags as declared in libvirt/libvirt-domain.h:3269
+type DomainGetJobStatsFlags int32
+
+// DomainGetJobStatsFlags enumeration from libvirt/libvirt-domain.h:3269
+const (
+	DomainJobStatsCompleted     DomainGetJobStatsFlags = 1
+	DomainJobStatsKeepCompleted DomainGetJobStatsFlags = 2
+)
+
+// DomainJobOperation as declared in libvirt/libvirt-domain.h:3295
+type DomainJobOperation int32
+
+// DomainJobOperation enumeration from libvirt/libvirt-domain.h:3295
+const (
+	DomainJobOperationStrUnknown        DomainJobOperation = iota
+	DomainJobOperationStrStart          DomainJobOperation = 1
+	DomainJobOperationStrSave           DomainJobOperation = 2
+	DomainJobOperationStrRestore        DomainJobOperation = 3
+	DomainJobOperationStrMigrationIn    DomainJobOperation = 4
+	DomainJobOperationStrMigrationOut   DomainJobOperation = 5
+	DomainJobOperationStrSnapshot       DomainJobOperation = 6
+	DomainJobOperationStrSnapshotRevert DomainJobOperation = 7
+	DomainJobOperationStrDump           DomainJobOperation = 8
+	DomainJobOperationStrBackup         DomainJobOperation = 9
+)
+
+// DomainEventWatchdogAction as declared in libvirt/libvirt-domain.h:3670
+type DomainEventWatchdogAction int32
+
+// DomainEventWatchdogAction enumeration from libvirt/libvirt-domain.h:3670
+const (
+	DomainEventWatchdogNone      DomainEventWatchdogAction = iota
+	DomainEventWatchdogPause     DomainEventWatchdogAction = 1
+	DomainEventWatchdogReset     DomainEventWatchdogAction = 2
+	DomainEventWatchdogPoweroff  DomainEventWatchdogAction = 3
+	DomainEventWatchdogShutdown  DomainEventWatchdogAction = 4
+	DomainEventWatchdogDebug     DomainEventWatchdogAction = 5
+	DomainEventWatchdogInjectnmi DomainEventWatchdogAction = 6
+)
+
+// DomainEventIOErrorAction as declared in libvirt/libvirt-domain.h:3701
+type DomainEventIOErrorAction int32
+
+// DomainEventIOErrorAction enumeration from libvirt/libvirt-domain.h:3701
+const (
+	DomainEventIoErrorNone   DomainEventIOErrorAction = iota
+	DomainEventIoErrorPause  DomainEventIOErrorAction = 1
+	DomainEventIoErrorReport DomainEventIOErrorAction = 2
+)
+
+// DomainEventGraphicsPhase as declared in libvirt/libvirt-domain.h:3764
+type DomainEventGraphicsPhase int32
+
+// DomainEventGraphicsPhase enumeration from libvirt/libvirt-domain.h:3764
+const (
+	DomainEventGraphicsConnect    DomainEventGraphicsPhase = iota
+	DomainEventGraphicsInitialize DomainEventGraphicsPhase = 1
+	DomainEventGraphicsDisconnect DomainEventGraphicsPhase = 2
+)
+
+// DomainEventGraphicsAddressType as declared in libvirt/libvirt-domain.h:3779
+type DomainEventGraphicsAddressType int32
+
+// DomainEventGraphicsAddressType enumeration from libvirt/libvirt-domain.h:3779
+const (
+	DomainEventGraphicsAddressIpv4 DomainEventGraphicsAddressType = iota
+	DomainEventGraphicsAddressIpv6 DomainEventGraphicsAddressType = 1
+	DomainEventGraphicsAddressUnix DomainEventGraphicsAddressType = 2
+)
+
+// ConnectDomainEventBlockJobStatus as declared in libvirt/libvirt-domain.h:3867
+type ConnectDomainEventBlockJobStatus int32
+
+// ConnectDomainEventBlockJobStatus enumeration from libvirt/libvirt-domain.h:3867
+const (
+	DomainBlockJobCompleted ConnectDomainEventBlockJobStatus = iota
+	DomainBlockJobFailed    ConnectDomainEventBlockJobStatus = 1
+	DomainBlockJobCanceled  ConnectDomainEventBlockJobStatus = 2
+	DomainBlockJobReady     ConnectDomainEventBlockJobStatus = 3
+)
+
+// ConnectDomainEventDiskChangeReason as declared in libvirt/libvirt-domain.h:3917
+type ConnectDomainEventDiskChangeReason int32
+
+// ConnectDomainEventDiskChangeReason enumeration from libvirt/libvirt-domain.h:3917
+const (
+	DomainEventDiskChangeMissingOnStart ConnectDomainEventDiskChangeReason = iota
+	DomainEventDiskDropMissingOnStart   ConnectDomainEventDiskChangeReason = 1
+)
+
+// DomainEventTrayChangeReason as declared in libvirt/libvirt-domain.h:3958
+type DomainEventTrayChangeReason int32
+
+// DomainEventTrayChangeReason enumeration from libvirt/libvirt-domain.h:3958
+const (
+	DomainEventTrayChangeOpen  DomainEventTrayChangeReason = iota
+	DomainEventTrayChangeClose DomainEventTrayChangeReason = 1
+)
+
+// ConnectDomainEventAgentLifecycleState as declared in libvirt/libvirt-domain.h:4475
+type ConnectDomainEventAgentLifecycleState int32
+
+// ConnectDomainEventAgentLifecycleState enumeration from libvirt/libvirt-domain.h:4475
+const (
+	ConnectDomainEventAgentLifecycleStateConnected    ConnectDomainEventAgentLifecycleState = 1
+	ConnectDomainEventAgentLifecycleStateDisconnected ConnectDomainEventAgentLifecycleState = 2
+)
+
+// ConnectDomainEventAgentLifecycleReason as declared in libvirt/libvirt-domain.h:4485
+type ConnectDomainEventAgentLifecycleReason int32
+
+// ConnectDomainEventAgentLifecycleReason enumeration from libvirt/libvirt-domain.h:4485
+const (
+	ConnectDomainEventAgentLifecycleReasonUnknown       ConnectDomainEventAgentLifecycleReason = iota
+	ConnectDomainEventAgentLifecycleReasonDomainStarted ConnectDomainEventAgentLifecycleReason = 1
+	ConnectDomainEventAgentLifecycleReasonChannel       ConnectDomainEventAgentLifecycleReason = 2
+)
+
+// DomainEventID as declared in libvirt/libvirt-domain.h:4589
+type DomainEventID int32
+
+// DomainEventID enumeration from libvirt/libvirt-domain.h:4589
+const (
+	DomainEventIDLifecycle           DomainEventID = iota
+	DomainEventIDReboot              DomainEventID = 1
+	DomainEventIDRtcChange           DomainEventID = 2
+	DomainEventIDWatchdog            DomainEventID = 3
+	DomainEventIDIoError             DomainEventID = 4
+	DomainEventIDGraphics            DomainEventID = 5
+	DomainEventIDIoErrorReason       DomainEventID = 6
+	DomainEventIDControlError        DomainEventID = 7
+	DomainEventIDBlockJob            DomainEventID = 8
+	DomainEventIDDiskChange          DomainEventID = 9
+	DomainEventIDTrayChange          DomainEventID = 10
+	DomainEventIDPmwakeup            DomainEventID = 11
+	DomainEventIDPmsuspend           DomainEventID = 12
+	DomainEventIDBalloonChange       DomainEventID = 13
+	DomainEventIDPmsuspendDisk       DomainEventID = 14
+	DomainEventIDDeviceRemoved       DomainEventID = 15
+	DomainEventIDBlockJob2           DomainEventID = 16
+	DomainEventIDTunable             DomainEventID = 17
+	DomainEventIDAgentLifecycle      DomainEventID = 18
+	DomainEventIDDeviceAdded         DomainEventID = 19
+	DomainEventIDMigrationIteration  DomainEventID = 20
+	DomainEventIDJobCompleted        DomainEventID = 21
+	DomainEventIDDeviceRemovalFailed DomainEventID = 22
+	DomainEventIDMetadataChange      DomainEventID = 23
+	DomainEventIDBlockThreshold      DomainEventID = 24
+)
+
+// DomainConsoleFlags as declared in libvirt/libvirt-domain.h:4616
+type DomainConsoleFlags int32
+
+// DomainConsoleFlags enumeration from libvirt/libvirt-domain.h:4616
+const (
+	DomainConsoleForce DomainConsoleFlags = 1
+	DomainConsoleSafe  DomainConsoleFlags = 2
+)
+
+// DomainChannelFlags as declared in libvirt/libvirt-domain.h:4632
+type DomainChannelFlags int32
+
+// DomainChannelFlags enumeration from libvirt/libvirt-domain.h:4632
+const (
+	DomainChannelForce DomainChannelFlags = 1
+)
+
+// DomainOpenGraphicsFlags as declared in libvirt/libvirt-domain.h:4641
+type DomainOpenGraphicsFlags int32
+
+// DomainOpenGraphicsFlags enumeration from libvirt/libvirt-domain.h:4641
+const (
+	DomainOpenGraphicsSkipauth DomainOpenGraphicsFlags = 1
+)
+
+// DomainSetTimeFlags as declared in libvirt/libvirt-domain.h:4698
+type DomainSetTimeFlags int32
+
+// DomainSetTimeFlags enumeration from libvirt/libvirt-domain.h:4698
+const (
+	DomainTimeSync DomainSetTimeFlags = 1
+)
+
+// SchedParameterType as declared in libvirt/libvirt-domain.h:4719
+type SchedParameterType int32
+
+// SchedParameterType enumeration from libvirt/libvirt-domain.h:4719
+const (
+	DomainSchedFieldInt     SchedParameterType = 1
+	DomainSchedFieldUint    SchedParameterType = 2
+	DomainSchedFieldLlong   SchedParameterType = 3
+	DomainSchedFieldUllong  SchedParameterType = 4
+	DomainSchedFieldDouble  SchedParameterType = 5
+	DomainSchedFieldBoolean SchedParameterType = 6
+)
+
+// BlkioParameterType as declared in libvirt/libvirt-domain.h:4763
+type BlkioParameterType int32
+
+// BlkioParameterType enumeration from libvirt/libvirt-domain.h:4763
+const (
+	DomainBlkioParamInt     BlkioParameterType = 1
+	DomainBlkioParamUint    BlkioParameterType = 2
+	DomainBlkioParamLlong   BlkioParameterType = 3
+	DomainBlkioParamUllong  BlkioParameterType = 4
+	DomainBlkioParamDouble  BlkioParameterType = 5
+	DomainBlkioParamBoolean BlkioParameterType = 6
+)
+
+// MemoryParameterType as declared in libvirt/libvirt-domain.h:4807
+type MemoryParameterType int32
+
+// MemoryParameterType enumeration from libvirt/libvirt-domain.h:4807
+const (
+	DomainMemoryParamInt     MemoryParameterType = 1
+	DomainMemoryParamUint    MemoryParameterType = 2
+	DomainMemoryParamLlong   MemoryParameterType = 3
+	DomainMemoryParamUllong  MemoryParameterType = 4
+	DomainMemoryParamDouble  MemoryParameterType = 5
+	DomainMemoryParamBoolean MemoryParameterType = 6
+)
+
+// DomainInterfaceAddressesSource as declared in libvirt/libvirt-domain.h:4845
+type DomainInterfaceAddressesSource int32
+
+// DomainInterfaceAddressesSource enumeration from libvirt/libvirt-domain.h:4845
+const (
+	DomainInterfaceAddressesSrcLease DomainInterfaceAddressesSource = iota
+	DomainInterfaceAddressesSrcAgent DomainInterfaceAddressesSource = 1
+	DomainInterfaceAddressesSrcArp   DomainInterfaceAddressesSource = 2
+)
+
+// DomainSetUserPasswordFlags as declared in libvirt/libvirt-domain.h:4873
+type DomainSetUserPasswordFlags int32
+
+// DomainSetUserPasswordFlags enumeration from libvirt/libvirt-domain.h:4873
+const (
+	DomainPasswordEncrypted DomainSetUserPasswordFlags = 1
+)
+
+// DomainLifecycle as declared in libvirt/libvirt-domain.h:4912
+type DomainLifecycle int32
+
+// DomainLifecycle enumeration from libvirt/libvirt-domain.h:4912
+const (
+	DomainLifecyclePoweroff DomainLifecycle = iota
+	DomainLifecycleReboot   DomainLifecycle = 1
+	DomainLifecycleCrash    DomainLifecycle = 2
+)
+
+// DomainLifecycleAction as declared in libvirt/libvirt-domain.h:4925
+type DomainLifecycleAction int32
+
+// DomainLifecycleAction enumeration from libvirt/libvirt-domain.h:4925
+const (
+	DomainLifecycleActionDestroy         DomainLifecycleAction = iota
+	DomainLifecycleActionRestart         DomainLifecycleAction = 1
+	DomainLifecycleActionRestartRename   DomainLifecycleAction = 2
+	DomainLifecycleActionPreserve        DomainLifecycleAction = 3
+	DomainLifecycleActionCoredumpDestroy DomainLifecycleAction = 4
+	DomainLifecycleActionCoredumpRestart DomainLifecycleAction = 5
+)
+
+// DomainGuestInfoTypes as declared in libvirt/libvirt-domain.h:4955
+type DomainGuestInfoTypes int32
+
+// DomainGuestInfoTypes enumeration from libvirt/libvirt-domain.h:4955
+const (
+	DomainGuestInfoUsers      DomainGuestInfoTypes = 1
+	DomainGuestInfoOs         DomainGuestInfoTypes = 2
+	DomainGuestInfoTimezone   DomainGuestInfoTypes = 4
+	DomainGuestInfoHostname   DomainGuestInfoTypes = 8
+	DomainGuestInfoFilesystem DomainGuestInfoTypes = 16
+)
+
+// DomainAgentResponseTimeoutValues as declared in libvirt/libvirt-domain.h:4967
+type DomainAgentResponseTimeoutValues int32
+
+// DomainAgentResponseTimeoutValues enumeration from libvirt/libvirt-domain.h:4967
+const (
+	DomainAgentResponseTimeoutBlock   DomainAgentResponseTimeoutValues = -2
+	DomainAgentResponseTimeoutDefault DomainAgentResponseTimeoutValues = -1
+	DomainAgentResponseTimeoutNowait  DomainAgentResponseTimeoutValues = 0
+)
+
+// DomainBackupBeginFlags as declared in libvirt/libvirt-domain.h:4976
+type DomainBackupBeginFlags int32
+
+// DomainBackupBeginFlags enumeration from libvirt/libvirt-domain.h:4976
+const (
+	DomainBackupBeginReuseExternal DomainBackupBeginFlags = 1
+)
+
+// DomainCheckpointCreateFlags as declared in libvirt/libvirt-domain-checkpoint.h:60
+type DomainCheckpointCreateFlags int32
+
+// DomainCheckpointCreateFlags enumeration from libvirt/libvirt-domain-checkpoint.h:60
+const (
+	DomainCheckpointCreateRedefine DomainCheckpointCreateFlags = 1
+	DomainCheckpointCreateQuiesce  DomainCheckpointCreateFlags = 2
+)
+
+// DomainCheckpointXMLFlags as declared in libvirt/libvirt-domain-checkpoint.h:73
+type DomainCheckpointXMLFlags int32
+
+// DomainCheckpointXMLFlags enumeration from libvirt/libvirt-domain-checkpoint.h:73
+const (
+	DomainCheckpointXMLSecure   DomainCheckpointXMLFlags = 1
+	DomainCheckpointXMLNoDomain DomainCheckpointXMLFlags = 2
+	DomainCheckpointXMLSize     DomainCheckpointXMLFlags = 4
+)
+
+// DomainCheckpointListFlags as declared in libvirt/libvirt-domain-checkpoint.h:103
+type DomainCheckpointListFlags int32
+
+// DomainCheckpointListFlags enumeration from libvirt/libvirt-domain-checkpoint.h:103
+const (
+	DomainCheckpointListRoots       DomainCheckpointListFlags = 1
+	DomainCheckpointListDescendants DomainCheckpointListFlags = 1
+	DomainCheckpointListTopological DomainCheckpointListFlags = 2
+	DomainCheckpointListLeaves      DomainCheckpointListFlags = 4
+	DomainCheckpointListNoLeaves    DomainCheckpointListFlags = 8
+)
+
+// DomainCheckpointDeleteFlags as declared in libvirt/libvirt-domain-checkpoint.h:129
+type DomainCheckpointDeleteFlags int32
+
+// DomainCheckpointDeleteFlags enumeration from libvirt/libvirt-domain-checkpoint.h:129
+const (
+	DomainCheckpointDeleteChildren     DomainCheckpointDeleteFlags = 1
+	DomainCheckpointDeleteMetadataOnly DomainCheckpointDeleteFlags = 2
+	DomainCheckpointDeleteChildrenOnly DomainCheckpointDeleteFlags = 4
+)
+
+// DomainSnapshotCreateFlags as declared in libvirt/libvirt-domain-snapshot.h:76
+type DomainSnapshotCreateFlags int32
+
+// DomainSnapshotCreateFlags enumeration from libvirt/libvirt-domain-snapshot.h:76
+const (
+	DomainSnapshotCreateRedefine   DomainSnapshotCreateFlags = 1
+	DomainSnapshotCreateCurrent    DomainSnapshotCreateFlags = 2
+	DomainSnapshotCreateNoMetadata DomainSnapshotCreateFlags = 4
+	DomainSnapshotCreateHalt       DomainSnapshotCreateFlags = 8
+	DomainSnapshotCreateDiskOnly   DomainSnapshotCreateFlags = 16
+	DomainSnapshotCreateReuseExt   DomainSnapshotCreateFlags = 32
+	DomainSnapshotCreateQuiesce    DomainSnapshotCreateFlags = 64
+	DomainSnapshotCreateAtomic     DomainSnapshotCreateFlags = 128
+	DomainSnapshotCreateLive       DomainSnapshotCreateFlags = 256
+	DomainSnapshotCreateValidate   DomainSnapshotCreateFlags = 512
+)
+
+// DomainSnapshotXMLFlags as declared in libvirt/libvirt-domain-snapshot.h:85
+type DomainSnapshotXMLFlags int32
+
+// DomainSnapshotXMLFlags enumeration from libvirt/libvirt-domain-snapshot.h:85
+const (
+	DomainSnapshotXMLSecure DomainSnapshotXMLFlags = 1
+)
+
+// DomainSnapshotListFlags as declared in libvirt/libvirt-domain-snapshot.h:144
+type DomainSnapshotListFlags int32
+
+// DomainSnapshotListFlags enumeration from libvirt/libvirt-domain-snapshot.h:144
+const (
+	DomainSnapshotListRoots       DomainSnapshotListFlags = 1
+	DomainSnapshotListDescendants DomainSnapshotListFlags = 1
+	DomainSnapshotListLeaves      DomainSnapshotListFlags = 4
+	DomainSnapshotListNoLeaves    DomainSnapshotListFlags = 8
+	DomainSnapshotListMetadata    DomainSnapshotListFlags = 2
+	DomainSnapshotListNoMetadata  DomainSnapshotListFlags = 16
+	DomainSnapshotListInactive    DomainSnapshotListFlags = 32
+	DomainSnapshotListActive      DomainSnapshotListFlags = 64
+	DomainSnapshotListDiskOnly    DomainSnapshotListFlags = 128
+	DomainSnapshotListInternal    DomainSnapshotListFlags = 256
+	DomainSnapshotListExternal    DomainSnapshotListFlags = 512
+	DomainSnapshotListTopological DomainSnapshotListFlags = 1024
+)
+
+// DomainSnapshotRevertFlags as declared in libvirt/libvirt-domain-snapshot.h:201
+type DomainSnapshotRevertFlags int32
+
+// DomainSnapshotRevertFlags enumeration from libvirt/libvirt-domain-snapshot.h:201
+const (
+	DomainSnapshotRevertRunning DomainSnapshotRevertFlags = 1
+	DomainSnapshotRevertPaused  DomainSnapshotRevertFlags = 2
+	DomainSnapshotRevertForce   DomainSnapshotRevertFlags = 4
+)
+
+// DomainSnapshotDeleteFlags as declared in libvirt/libvirt-domain-snapshot.h:215
+type DomainSnapshotDeleteFlags int32
+
+// DomainSnapshotDeleteFlags enumeration from libvirt/libvirt-domain-snapshot.h:215
+const (
+	DomainSnapshotDeleteChildren     DomainSnapshotDeleteFlags = 1
+	DomainSnapshotDeleteMetadataOnly DomainSnapshotDeleteFlags = 2
+	DomainSnapshotDeleteChildrenOnly DomainSnapshotDeleteFlags = 4
+)
+
+// EventHandleType as declared in libvirt/libvirt-event.h:43
+type EventHandleType int32
+
+// EventHandleType enumeration from libvirt/libvirt-event.h:43
+const (
+	EventHandleReadable EventHandleType = 1
+	EventHandleWritable EventHandleType = 2
+	EventHandleError    EventHandleType = 4
+	EventHandleHangup   EventHandleType = 8
+)
+
+// ConnectListAllInterfacesFlags as declared in libvirt/libvirt-interface.h:64
+type ConnectListAllInterfacesFlags int32
+
+// ConnectListAllInterfacesFlags enumeration from libvirt/libvirt-interface.h:64
+const (
+	ConnectListInterfacesInactive ConnectListAllInterfacesFlags = 1
+	ConnectListInterfacesActive   ConnectListAllInterfacesFlags = 2
+)
+
+// InterfaceXMLFlags as declared in libvirt/libvirt-interface.h:80
+type InterfaceXMLFlags int32
+
+// InterfaceXMLFlags enumeration from libvirt/libvirt-interface.h:80
+const (
+	InterfaceXMLInactive InterfaceXMLFlags = 1
+)
+
+// NetworkXMLFlags as declared in libvirt/libvirt-network.h:32
+type NetworkXMLFlags int32
+
+// NetworkXMLFlags enumeration from libvirt/libvirt-network.h:32
+const (
+	NetworkXMLInactive NetworkXMLFlags = 1
+)
+
+// ConnectListAllNetworksFlags as declared in libvirt/libvirt-network.h:100
+type ConnectListAllNetworksFlags int32
+
+// ConnectListAllNetworksFlags enumeration from libvirt/libvirt-network.h:100
+const (
+	ConnectListNetworksInactive    ConnectListAllNetworksFlags = 1
+	ConnectListNetworksActive      ConnectListAllNetworksFlags = 2
+	ConnectListNetworksPersistent  ConnectListAllNetworksFlags = 4
+	ConnectListNetworksTransient   ConnectListAllNetworksFlags = 8
+	ConnectListNetworksAutostart   ConnectListAllNetworksFlags = 16
+	ConnectListNetworksNoAutostart ConnectListAllNetworksFlags = 32
+)
+
+// NetworkUpdateCommand as declared in libvirt/libvirt-network.h:149
+type NetworkUpdateCommand int32
+
+// NetworkUpdateCommand enumeration from libvirt/libvirt-network.h:149
+const (
+	NetworkUpdateCommandNone     NetworkUpdateCommand = iota
+	NetworkUpdateCommandModify   NetworkUpdateCommand = 1
+	NetworkUpdateCommandDelete   NetworkUpdateCommand = 2
+	NetworkUpdateCommandAddLast  NetworkUpdateCommand = 3
+	NetworkUpdateCommandAddFirst NetworkUpdateCommand = 4
+)
+
+// NetworkUpdateSection as declared in libvirt/libvirt-network.h:175
+type NetworkUpdateSection int32
+
+// NetworkUpdateSection enumeration from libvirt/libvirt-network.h:175
+const (
+	NetworkSectionNone             NetworkUpdateSection = iota
+	NetworkSectionBridge           NetworkUpdateSection = 1
+	NetworkSectionDomain           NetworkUpdateSection = 2
+	NetworkSectionIP               NetworkUpdateSection = 3
+	NetworkSectionIPDhcpHost       NetworkUpdateSection = 4
+	NetworkSectionIPDhcpRange      NetworkUpdateSection = 5
+	NetworkSectionForward          NetworkUpdateSection = 6
+	NetworkSectionForwardInterface NetworkUpdateSection = 7
+	NetworkSectionForwardPf        NetworkUpdateSection = 8
+	NetworkSectionPortgroup        NetworkUpdateSection = 9
+	NetworkSectionDNSHost          NetworkUpdateSection = 10
+	NetworkSectionDNSTxt           NetworkUpdateSection = 11
+	NetworkSectionDNSSrv           NetworkUpdateSection = 12
+)
+
+// NetworkUpdateFlags as declared in libvirt/libvirt-network.h:187
+type NetworkUpdateFlags int32
+
+// NetworkUpdateFlags enumeration from libvirt/libvirt-network.h:187
+const (
+	NetworkUpdateAffectCurrent NetworkUpdateFlags = iota
+	NetworkUpdateAffectLive    NetworkUpdateFlags = 1
+	NetworkUpdateAffectConfig  NetworkUpdateFlags = 2
+)
+
+// NetworkEventLifecycleType as declared in libvirt/libvirt-network.h:245
+type NetworkEventLifecycleType int32
+
+// NetworkEventLifecycleType enumeration from libvirt/libvirt-network.h:245
+const (
+	NetworkEventDefined   NetworkEventLifecycleType = iota
+	NetworkEventUndefined NetworkEventLifecycleType = 1
+	NetworkEventStarted   NetworkEventLifecycleType = 2
+	NetworkEventStopped   NetworkEventLifecycleType = 3
+)
+
+// NetworkEventID as declared in libvirt/libvirt-network.h:293
+type NetworkEventID int32
+
+// NetworkEventID enumeration from libvirt/libvirt-network.h:293
+const (
+	NetworkEventIDLifecycle NetworkEventID = iota
+)
+
+// IPAddrType as declared in libvirt/libvirt-network.h:302
+type IPAddrType int32
+
+// IPAddrType enumeration from libvirt/libvirt-network.h:302
+const (
+	IPAddrTypeIpv4 IPAddrType = iota
+	IPAddrTypeIpv6 IPAddrType = 1
+)
+
+// NetworkPortCreateFlags as declared in libvirt/libvirt-network.h:363
+type NetworkPortCreateFlags int32
+
+// NetworkPortCreateFlags enumeration from libvirt/libvirt-network.h:363
+const (
+	NetworkPortCreateReclaim NetworkPortCreateFlags = 1
+)
+
+// ConnectListAllNodeDeviceFlags as declared in libvirt/libvirt-nodedev.h:84
+type ConnectListAllNodeDeviceFlags int32
+
+// ConnectListAllNodeDeviceFlags enumeration from libvirt/libvirt-nodedev.h:84
+const (
+	ConnectListNodeDevicesCapSystem       ConnectListAllNodeDeviceFlags = 1
+	ConnectListNodeDevicesCapPciDev       ConnectListAllNodeDeviceFlags = 2
+	ConnectListNodeDevicesCapUsbDev       ConnectListAllNodeDeviceFlags = 4
+	ConnectListNodeDevicesCapUsbInterface ConnectListAllNodeDeviceFlags = 8
+	ConnectListNodeDevicesCapNet          ConnectListAllNodeDeviceFlags = 16
+	ConnectListNodeDevicesCapScsiHost     ConnectListAllNodeDeviceFlags = 32
+	ConnectListNodeDevicesCapScsiTarget   ConnectListAllNodeDeviceFlags = 64
+	ConnectListNodeDevicesCapScsi         ConnectListAllNodeDeviceFlags = 128
+	ConnectListNodeDevicesCapStorage      ConnectListAllNodeDeviceFlags = 256
+	ConnectListNodeDevicesCapFcHost       ConnectListAllNodeDeviceFlags = 512
+	ConnectListNodeDevicesCapVports       ConnectListAllNodeDeviceFlags = 1024
+	ConnectListNodeDevicesCapScsiGeneric  ConnectListAllNodeDeviceFlags = 2048
+	ConnectListNodeDevicesCapDrm          ConnectListAllNodeDeviceFlags = 4096
+	ConnectListNodeDevicesCapMdevTypes    ConnectListAllNodeDeviceFlags = 8192
+	ConnectListNodeDevicesCapMdev         ConnectListAllNodeDeviceFlags = 16384
+	ConnectListNodeDevicesCapCcwDev       ConnectListAllNodeDeviceFlags = 32768
+)
+
+// NodeDeviceEventID as declared in libvirt/libvirt-nodedev.h:154
+type NodeDeviceEventID int32
+
+// NodeDeviceEventID enumeration from libvirt/libvirt-nodedev.h:154
+const (
+	NodeDeviceEventIDLifecycle NodeDeviceEventID = iota
+	NodeDeviceEventIDUpdate    NodeDeviceEventID = 1
+)
+
+// NodeDeviceEventLifecycleType as declared in libvirt/libvirt-nodedev.h:196
+type NodeDeviceEventLifecycleType int32
+
+// NodeDeviceEventLifecycleType enumeration from libvirt/libvirt-nodedev.h:196
+const (
+	NodeDeviceEventCreated NodeDeviceEventLifecycleType = iota
+	NodeDeviceEventDeleted NodeDeviceEventLifecycleType = 1
+)
+
+// SecretUsageType as declared in libvirt/libvirt-secret.h:56
+type SecretUsageType int32
+
+// SecretUsageType enumeration from libvirt/libvirt-secret.h:56
+const (
+	SecretUsageTypeNone   SecretUsageType = iota
+	SecretUsageTypeVolume SecretUsageType = 1
+	SecretUsageTypeCeph   SecretUsageType = 2
+	SecretUsageTypeIscsi  SecretUsageType = 3
+	SecretUsageTypeTLS    SecretUsageType = 4
+	SecretUsageTypeVtpm   SecretUsageType = 5
+)
+
+// ConnectListAllSecretsFlags as declared in libvirt/libvirt-secret.h:79
+type ConnectListAllSecretsFlags int32
+
+// ConnectListAllSecretsFlags enumeration from libvirt/libvirt-secret.h:79
+const (
+	ConnectListSecretsEphemeral   ConnectListAllSecretsFlags = 1
+	ConnectListSecretsNoEphemeral ConnectListAllSecretsFlags = 2
+	ConnectListSecretsPrivate     ConnectListAllSecretsFlags = 4
+	ConnectListSecretsNoPrivate   ConnectListAllSecretsFlags = 8
+)
+
+// SecretEventID as declared in libvirt/libvirt-secret.h:140
+type SecretEventID int32
+
+// SecretEventID enumeration from libvirt/libvirt-secret.h:140
+const (
+	SecretEventIDLifecycle    SecretEventID = iota
+	SecretEventIDValueChanged SecretEventID = 1
+)
+
+// SecretEventLifecycleType as declared in libvirt/libvirt-secret.h:182
+type SecretEventLifecycleType int32
+
+// SecretEventLifecycleType enumeration from libvirt/libvirt-secret.h:182
+const (
+	SecretEventDefined   SecretEventLifecycleType = iota
+	SecretEventUndefined SecretEventLifecycleType = 1
+)
+
+// StoragePoolState as declared in libvirt/libvirt-storage.h:57
+type StoragePoolState int32
+
+// StoragePoolState enumeration from libvirt/libvirt-storage.h:57
+const (
+	StoragePoolInactive     StoragePoolState = iota
+	StoragePoolBuilding     StoragePoolState = 1
+	StoragePoolRunning      StoragePoolState = 2
+	StoragePoolDegraded     StoragePoolState = 3
+	StoragePoolInaccessible StoragePoolState = 4
+)
+
+// StoragePoolBuildFlags as declared in libvirt/libvirt-storage.h:65
+type StoragePoolBuildFlags int32
+
+// StoragePoolBuildFlags enumeration from libvirt/libvirt-storage.h:65
+const (
+	StoragePoolBuildNew         StoragePoolBuildFlags = iota
+	StoragePoolBuildRepair      StoragePoolBuildFlags = 1
+	StoragePoolBuildResize      StoragePoolBuildFlags = 2
+	StoragePoolBuildNoOverwrite StoragePoolBuildFlags = 4
+	StoragePoolBuildOverwrite   StoragePoolBuildFlags = 8
+)
+
+// StoragePoolDeleteFlags as declared in libvirt/libvirt-storage.h:70
+type StoragePoolDeleteFlags int32
+
+// StoragePoolDeleteFlags enumeration from libvirt/libvirt-storage.h:70
+const (
+	StoragePoolDeleteNormal StoragePoolDeleteFlags = iota
+	StoragePoolDeleteZeroed StoragePoolDeleteFlags = 1
+)
+
+// StoragePoolCreateFlags as declared in libvirt/libvirt-storage.h:87
+type StoragePoolCreateFlags int32
+
+// StoragePoolCreateFlags enumeration from libvirt/libvirt-storage.h:87
+const (
+	StoragePoolCreateNormal               StoragePoolCreateFlags = iota
+	StoragePoolCreateWithBuild            StoragePoolCreateFlags = 1
+	StoragePoolCreateWithBuildOverwrite   StoragePoolCreateFlags = 2
+	StoragePoolCreateWithBuildNoOverwrite StoragePoolCreateFlags = 4
+)
+
+// StorageVolType as declared in libvirt/libvirt-storage.h:129
+type StorageVolType int32
+
+// StorageVolType enumeration from libvirt/libvirt-storage.h:129
+const (
+	StorageVolFile    StorageVolType = iota
+	StorageVolBlock   StorageVolType = 1
+	StorageVolDir     StorageVolType = 2
+	StorageVolNetwork StorageVolType = 3
+	StorageVolNetdir  StorageVolType = 4
+	StorageVolPloop   StorageVolType = 5
+)
+
+// StorageVolDeleteFlags as declared in libvirt/libvirt-storage.h:135
+type StorageVolDeleteFlags int32
+
+// StorageVolDeleteFlags enumeration from libvirt/libvirt-storage.h:135
+const (
+	StorageVolDeleteNormal        StorageVolDeleteFlags = iota
+	StorageVolDeleteZeroed        StorageVolDeleteFlags = 1
+	StorageVolDeleteWithSnapshots StorageVolDeleteFlags = 2
+)
+
+// StorageVolWipeAlgorithm as declared in libvirt/libvirt-storage.h:167
+type StorageVolWipeAlgorithm int32
+
+// StorageVolWipeAlgorithm enumeration from libvirt/libvirt-storage.h:167
+const (
+	StorageVolWipeAlgZero       StorageVolWipeAlgorithm = iota
+	StorageVolWipeAlgNnsa       StorageVolWipeAlgorithm = 1
+	StorageVolWipeAlgDod        StorageVolWipeAlgorithm = 2
+	StorageVolWipeAlgBsi        StorageVolWipeAlgorithm = 3
+	StorageVolWipeAlgGutmann    StorageVolWipeAlgorithm = 4
+	StorageVolWipeAlgSchneier   StorageVolWipeAlgorithm = 5
+	StorageVolWipeAlgPfitzner7  StorageVolWipeAlgorithm = 6
+	StorageVolWipeAlgPfitzner33 StorageVolWipeAlgorithm = 7
+	StorageVolWipeAlgRandom     StorageVolWipeAlgorithm = 8
+	StorageVolWipeAlgTrim       StorageVolWipeAlgorithm = 9
+)
+
+// StorageVolInfoFlags as declared in libvirt/libvirt-storage.h:175
+type StorageVolInfoFlags int32
+
+// StorageVolInfoFlags enumeration from libvirt/libvirt-storage.h:175
+const (
+	StorageVolUseAllocation StorageVolInfoFlags = iota
+	StorageVolGetPhysical   StorageVolInfoFlags = 1
+)
+
+// StorageXMLFlags as declared in libvirt/libvirt-storage.h:189
+type StorageXMLFlags int32
+
+// StorageXMLFlags enumeration from libvirt/libvirt-storage.h:189
+const (
+	StorageXMLInactive StorageXMLFlags = 1
+)
+
+// ConnectListAllStoragePoolsFlags as declared in libvirt/libvirt-storage.h:248
+type ConnectListAllStoragePoolsFlags int32
+
+// ConnectListAllStoragePoolsFlags enumeration from libvirt/libvirt-storage.h:248
+const (
+	ConnectListStoragePoolsInactive    ConnectListAllStoragePoolsFlags = 1
+	ConnectListStoragePoolsActive      ConnectListAllStoragePoolsFlags = 2
+	ConnectListStoragePoolsPersistent  ConnectListAllStoragePoolsFlags = 4
+	ConnectListStoragePoolsTransient   ConnectListAllStoragePoolsFlags = 8
+	ConnectListStoragePoolsAutostart   ConnectListAllStoragePoolsFlags = 16
+	ConnectListStoragePoolsNoAutostart ConnectListAllStoragePoolsFlags = 32
+	ConnectListStoragePoolsDir         ConnectListAllStoragePoolsFlags = 64
+	ConnectListStoragePoolsFs          ConnectListAllStoragePoolsFlags = 128
+	ConnectListStoragePoolsNetfs       ConnectListAllStoragePoolsFlags = 256
+	ConnectListStoragePoolsLogical     ConnectListAllStoragePoolsFlags = 512
+	ConnectListStoragePoolsDisk        ConnectListAllStoragePoolsFlags = 1024
+	ConnectListStoragePoolsIscsi       ConnectListAllStoragePoolsFlags = 2048
+	ConnectListStoragePoolsScsi        ConnectListAllStoragePoolsFlags = 4096
+	ConnectListStoragePoolsMpath       ConnectListAllStoragePoolsFlags = 8192
+	ConnectListStoragePoolsRbd         ConnectListAllStoragePoolsFlags = 16384
+	ConnectListStoragePoolsSheepdog    ConnectListAllStoragePoolsFlags = 32768
+	ConnectListStoragePoolsGluster     ConnectListAllStoragePoolsFlags = 65536
+	ConnectListStoragePoolsZfs         ConnectListAllStoragePoolsFlags = 131072
+	ConnectListStoragePoolsVstorage    ConnectListAllStoragePoolsFlags = 262144
+	ConnectListStoragePoolsIscsiDirect ConnectListAllStoragePoolsFlags = 524288
+)
+
+// StorageVolCreateFlags as declared in libvirt/libvirt-storage.h:346
+type StorageVolCreateFlags int32
+
+// StorageVolCreateFlags enumeration from libvirt/libvirt-storage.h:346
+const (
+	StorageVolCreatePreallocMetadata StorageVolCreateFlags = 1
+	StorageVolCreateReflink          StorageVolCreateFlags = 2
+)
+
+// StorageVolDownloadFlags as declared in libvirt/libvirt-storage.h:358
+type StorageVolDownloadFlags int32
+
+// StorageVolDownloadFlags enumeration from libvirt/libvirt-storage.h:358
+const (
+	StorageVolDownloadSparseStream StorageVolDownloadFlags = 1
+)
+
+// StorageVolUploadFlags as declared in libvirt/libvirt-storage.h:367
+type StorageVolUploadFlags int32
+
+// StorageVolUploadFlags enumeration from libvirt/libvirt-storage.h:367
+const (
+	StorageVolUploadSparseStream StorageVolUploadFlags = 1
+)
+
+// StorageVolResizeFlags as declared in libvirt/libvirt-storage.h:398
+type StorageVolResizeFlags int32
+
+// StorageVolResizeFlags enumeration from libvirt/libvirt-storage.h:398
+const (
+	StorageVolResizeAllocate StorageVolResizeFlags = 1
+	StorageVolResizeDelta    StorageVolResizeFlags = 2
+	StorageVolResizeShrink   StorageVolResizeFlags = 4
+)
+
+// StoragePoolEventID as declared in libvirt/libvirt-storage.h:434
+type StoragePoolEventID int32
+
+// StoragePoolEventID enumeration from libvirt/libvirt-storage.h:434
+const (
+	StoragePoolEventIDLifecycle StoragePoolEventID = iota
+	StoragePoolEventIDRefresh   StoragePoolEventID = 1
+)
+
+// StoragePoolEventLifecycleType as declared in libvirt/libvirt-storage.h:480
+type StoragePoolEventLifecycleType int32
+
+// StoragePoolEventLifecycleType enumeration from libvirt/libvirt-storage.h:480
+const (
+	StoragePoolEventDefined   StoragePoolEventLifecycleType = iota
+	StoragePoolEventUndefined StoragePoolEventLifecycleType = 1
+	StoragePoolEventStarted   StoragePoolEventLifecycleType = 2
+	StoragePoolEventStopped   StoragePoolEventLifecycleType = 3
+	StoragePoolEventCreated   StoragePoolEventLifecycleType = 4
+	StoragePoolEventDeleted   StoragePoolEventLifecycleType = 5
+)
+
+// StreamFlags as declared in libvirt/libvirt-stream.h:33
+type StreamFlags int32
+
+// StreamFlags enumeration from libvirt/libvirt-stream.h:33
+const (
+	StreamNonblock StreamFlags = 1
+)
+
+// StreamRecvFlagsValues as declared in libvirt/libvirt-stream.h:49
+type StreamRecvFlagsValues int32
+
+// StreamRecvFlagsValues enumeration from libvirt/libvirt-stream.h:49
+const (
+	StreamRecvStopAtHole StreamRecvFlagsValues = 1
+)
+
+// StreamEventType as declared in libvirt/libvirt-stream.h:237
+type StreamEventType int32
+
+// StreamEventType enumeration from libvirt/libvirt-stream.h:237
+const (
+	StreamEventReadable StreamEventType = 1
+	StreamEventWritable StreamEventType = 2
+	StreamEventError    StreamEventType = 4
+	StreamEventHangup   StreamEventType = 8
+)
+
+// errorLevel as declared in libvirt/virterror.h:42
+type errorLevel int32
+
+// errorLevel enumeration from libvirt/virterror.h:42
+const (
+	errNone    errorLevel = iota
+	errWarning errorLevel = 1
+	errError   errorLevel = 2
+)
+
+// errorDomain as declared in libvirt/virterror.h:143
+type errorDomain int32
+
+// errorDomain enumeration from libvirt/virterror.h:143
+const (
+	fromNone             errorDomain = iota
+	fromXen              errorDomain = 1
+	fromXend             errorDomain = 2
+	fromXenstore         errorDomain = 3
+	fromSexpr            errorDomain = 4
+	fromXML              errorDomain = 5
+	fromDom              errorDomain = 6
+	fromRPC              errorDomain = 7
+	fromProxy            errorDomain = 8
+	fromConf             errorDomain = 9
+	fromQemu             errorDomain = 10
+	fromNet              errorDomain = 11
+	fromTest             errorDomain = 12
+	fromRemote           errorDomain = 13
+	fromOpenvz           errorDomain = 14
+	fromXenxm            errorDomain = 15
+	fromStatsLinux       errorDomain = 16
+	fromLxc              errorDomain = 17
+	fromStorage          errorDomain = 18
+	fromNetwork          errorDomain = 19
+	fromDomain           errorDomain = 20
+	fromUml              errorDomain = 21
+	fromNodedev          errorDomain = 22
+	fromXenInotify       errorDomain = 23
+	fromSecurity         errorDomain = 24
+	fromVbox             errorDomain = 25
+	fromInterface        errorDomain = 26
+	fromOne              errorDomain = 27
+	fromEsx              errorDomain = 28
+	fromPhyp             errorDomain = 29
+	fromSecret           errorDomain = 30
+	fromCPU              errorDomain = 31
+	fromXenapi           errorDomain = 32
+	fromNwfilter         errorDomain = 33
+	fromHook             errorDomain = 34
+	fromDomainSnapshot   errorDomain = 35
+	fromAudit            errorDomain = 36
+	fromSysinfo          errorDomain = 37
+	fromStreams          errorDomain = 38
+	fromVmware           errorDomain = 39
+	fromEvent            errorDomain = 40
+	fromLibxl            errorDomain = 41
+	fromLocking          errorDomain = 42
+	fromHyperv           errorDomain = 43
+	fromCapabilities     errorDomain = 44
+	fromURI              errorDomain = 45
+	fromAuth             errorDomain = 46
+	fromDbus             errorDomain = 47
+	fromParallels        errorDomain = 48
+	fromDevice           errorDomain = 49
+	fromSSH              errorDomain = 50
+	fromLockspace        errorDomain = 51
+	fromInitctl          errorDomain = 52
+	fromIdentity         errorDomain = 53
+	fromCgroup           errorDomain = 54
+	fromAccess           errorDomain = 55
+	fromSystemd          errorDomain = 56
+	fromBhyve            errorDomain = 57
+	fromCrypto           errorDomain = 58
+	fromFirewall         errorDomain = 59
+	fromPolkit           errorDomain = 60
+	fromThread           errorDomain = 61
+	fromAdmin            errorDomain = 62
+	fromLogging          errorDomain = 63
+	fromXenxl            errorDomain = 64
+	fromPerf             errorDomain = 65
+	fromLibssh           errorDomain = 66
+	fromResctrl          errorDomain = 67
+	fromFirewalld        errorDomain = 68
+	fromDomainCheckpoint errorDomain = 69
+	fromTpm              errorDomain = 70
+	fromBpf              errorDomain = 71
+)
+
+// errorNumber as declared in libvirt/virterror.h:340
+type errorNumber int32
+
+// errorNumber enumeration from libvirt/virterror.h:340
+const (
+	errOk                      errorNumber = iota
+	errInternalError           errorNumber = 1
+	errNoMemory                errorNumber = 2
+	errNoSupport               errorNumber = 3
+	errUnknownHost             errorNumber = 4
+	errNoConnect               errorNumber = 5
+	errInvalidConn             errorNumber = 6
+	errInvalidDomain           errorNumber = 7
+	errInvalidArg              errorNumber = 8
+	errOperationFailed         errorNumber = 9
+	errGetFailed               errorNumber = 10
+	errPostFailed              errorNumber = 11
+	errHTTPError               errorNumber = 12
+	errSexprSerial             errorNumber = 13
+	errNoXen                   errorNumber = 14
+	errXenCall                 errorNumber = 15
+	errOsType                  errorNumber = 16
+	errNoKernel                errorNumber = 17
+	errNoRoot                  errorNumber = 18
+	errNoSource                errorNumber = 19
+	errNoTarget                errorNumber = 20
+	errNoName                  errorNumber = 21
+	errNoOs                    errorNumber = 22
+	errNoDevice                errorNumber = 23
+	errNoXenstore              errorNumber = 24
+	errDriverFull              errorNumber = 25
+	errCallFailed              errorNumber = 26
+	errXMLError                errorNumber = 27
+	errDomExist                errorNumber = 28
+	errOperationDenied         errorNumber = 29
+	errOpenFailed              errorNumber = 30
+	errReadFailed              errorNumber = 31
+	errParseFailed             errorNumber = 32
+	errConfSyntax              errorNumber = 33
+	errWriteFailed             errorNumber = 34
+	errXMLDetail               errorNumber = 35
+	errInvalidNetwork          errorNumber = 36
+	errNetworkExist            errorNumber = 37
+	errSystemError             errorNumber = 38
+	errRPC                     errorNumber = 39
+	errGnutlsError             errorNumber = 40
+	warNoNetwork               errorNumber = 41
+	errNoDomain                errorNumber = 42
+	errNoNetwork               errorNumber = 43
+	errInvalidMac              errorNumber = 44
+	errAuthFailed              errorNumber = 45
+	errInvalidStoragePool      errorNumber = 46
+	errInvalidStorageVol       errorNumber = 47
+	warNoStorage               errorNumber = 48
+	errNoStoragePool           errorNumber = 49
+	errNoStorageVol            errorNumber = 50
+	warNoNode                  errorNumber = 51
+	errInvalidNodeDevice       errorNumber = 52
+	errNoNodeDevice            errorNumber = 53
+	errNoSecurityModel         errorNumber = 54
+	errOperationInvalid        errorNumber = 55
+	warNoInterface             errorNumber = 56
+	errNoInterface             errorNumber = 57
+	errInvalidInterface        errorNumber = 58
+	errMultipleInterfaces      errorNumber = 59
+	warNoNwfilter              errorNumber = 60
+	errInvalidNwfilter         errorNumber = 61
+	errNoNwfilter              errorNumber = 62
+	errBuildFirewall           errorNumber = 63
+	warNoSecret                errorNumber = 64
+	errInvalidSecret           errorNumber = 65
+	errNoSecret                errorNumber = 66
+	errConfigUnsupported       errorNumber = 67
+	errOperationTimeout        errorNumber = 68
+	errMigratePersistFailed    errorNumber = 69
+	errHookScriptFailed        errorNumber = 70
+	errInvalidDomainSnapshot   errorNumber = 71
+	errNoDomainSnapshot        errorNumber = 72
+	errInvalidStream           errorNumber = 73
+	errArgumentUnsupported     errorNumber = 74
+	errStorageProbeFailed      errorNumber = 75
+	errStoragePoolBuilt        errorNumber = 76
+	errSnapshotRevertRisky     errorNumber = 77
+	errOperationAborted        errorNumber = 78
+	errAuthCancelled           errorNumber = 79
+	errNoDomainMetadata        errorNumber = 80
+	errMigrateUnsafe           errorNumber = 81
+	errOverflow                errorNumber = 82
+	errBlockCopyActive         errorNumber = 83
+	errOperationUnsupported    errorNumber = 84
+	errSSH                     errorNumber = 85
+	errAgentUnresponsive       errorNumber = 86
+	errResourceBusy            errorNumber = 87
+	errAccessDenied            errorNumber = 88
+	errDbusService             errorNumber = 89
+	errStorageVolExist         errorNumber = 90
+	errCPUIncompatible         errorNumber = 91
+	errXMLInvalidSchema        errorNumber = 92
+	errMigrateFinishOk         errorNumber = 93
+	errAuthUnavailable         errorNumber = 94
+	errNoServer                errorNumber = 95
+	errNoClient                errorNumber = 96
+	errAgentUnsynced           errorNumber = 97
+	errLibssh                  errorNumber = 98
+	errDeviceMissing           errorNumber = 99
+	errInvalidNwfilterBinding  errorNumber = 100
+	errNoNwfilterBinding       errorNumber = 101
+	errInvalidDomainCheckpoint errorNumber = 102
+	errNoDomainCheckpoint      errorNumber = 103
+	errNoDomainBackup          errorNumber = 104
+	errInvalidNetworkPort      errorNumber = 105
+	errNetworkPortExist        errorNumber = 106
+	errNoNetworkPort           errorNumber = 107
+	errNoHostname              errorNumber = 108
+	errCheckpointInconsistent  errorNumber = 109
+)
diff --git a/vendor/github.com/digitalocean/go-libvirt/doc.go b/vendor/github.com/digitalocean/go-libvirt/doc.go
new file mode 100644
index 000000000..1229f30c8
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/doc.go
@@ -0,0 +1,76 @@
+// Copyright 2016 The go-libvirt Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/*
+	Package libvirt provides a pure Go interface for Libvirt.
+
+	Rather than using Libvirt's C bindings, this package makes use of
+	Libvirt's RPC interface, as documented here: https://libvirt.org/internals/rpc.html.
+	Connections to the libvirt server may be local, or remote. RPC packets are encoded
+	using the XDR standard as defined by RFC 4506.
+
+	This should be considered a work in progress. Most functionaly provided by the C
+	bindings have not yet made their way into this library. Pull requests are welcome!
+	The definition of the RPC protocol is in the libvirt source tree under src/rpc/virnetprotocol.x.
+
+	Example usage:
+
+	package main
+
+	import (
+		"fmt"
+		"log"
+		"net"
+		"time"
+
+		"github.com/digitalocean/go-libvirt"
+	)
+
+	func main() {
+		//c, err := net.DialTimeout("tcp", "127.0.0.1:16509", 2*time.Second)
+		//c, err := net.DialTimeout("tcp", "192.168.1.12:16509", 2*time.Second)
+		c, err := net.DialTimeout("unix", "/var/run/libvirt/libvirt-sock", 2*time.Second)
+		if err != nil {
+			log.Fatalf("failed to dial libvirt: %v", err)
+		}
+
+		l := libvirt.New(c)
+		if err := l.Connect(); err != nil {
+			log.Fatalf("failed to connect: %v", err)
+		}
+
+		v, err := l.Version()
+		if err != nil {
+			log.Fatalf("failed to retrieve libvirt version: %v", err)
+		}
+		fmt.Println("Version:", v)
+
+		domains, err := l.Domains()
+		if err != nil {
+			log.Fatalf("failed to retrieve domains: %v", err)
+		}
+
+		fmt.Println("ID\tName\t\tUUID")
+		fmt.Printf("--------------------------------------------------------\n")
+		for _, d := range domains {
+			fmt.Printf("%d\t%s\t%x\n", d.ID, d.Name, d.UUID)
+		}
+
+		if err := l.Disconnect(); err != nil {
+			log.Fatal("failed to disconnect: %v", err)
+		}
+	}
+*/
+
+package libvirt
diff --git a/vendor/github.com/digitalocean/go-libvirt/go.mod b/vendor/github.com/digitalocean/go-libvirt/go.mod
new file mode 100644
index 000000000..b0957576a
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/go.mod
@@ -0,0 +1,9 @@
+module github.com/digitalocean/go-libvirt
+
+go 1.14
+
+require (
+	github.com/stretchr/testify v1.6.1
+	golang.org/x/net v0.0.0-20200625001655-4c5254603344
+	golang.org/x/tools v0.0.0-20200711155855-7342f9734a7d
+)
diff --git a/vendor/github.com/digitalocean/go-libvirt/go.sum b/vendor/github.com/digitalocean/go-libvirt/go.sum
new file mode 100644
index 000000000..a213b4803
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/go.sum
@@ -0,0 +1,35 @@
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
+github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/mod v0.3.0 h1:RM4zey1++hCTbCVQfnWeKs9/IEsaBLA8vTkd0WVtmH4=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200625001655-4c5254603344 h1:vGXIOMxbNfDTk/aXCmfdLgkrSV+Z2tcbze+pEc3v5W4=
+golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20200711155855-7342f9734a7d h1:F3OmlXCzYtG9YE6tXDnUOlJBzVzHF8EcmZ1yTJlcgIk=
+golang.org/x/tools v0.0.0-20200711155855-7342f9734a7d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898 h1:/atklqdjdhuosWIl6AIbOeHJjicWYPqR9bpxqxYG2pA=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/vendor/github.com/digitalocean/go-libvirt/internal/constants/qemu_protocol.gen.go b/vendor/github.com/digitalocean/go-libvirt/internal/constants/qemu_protocol.gen.go
new file mode 100644
index 000000000..208986dee
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/internal/constants/qemu_protocol.gen.go
@@ -0,0 +1,47 @@
+// Copyright 2018 The go-libvirt Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//
+// Code generated by internal/lvgen/generate.go. DO NOT EDIT.
+//
+// To regenerate, run 'go generate' in internal/lvgen.
+//
+
+package constants
+
+// These are libvirt procedure numbers which correspond to each respective
+// API call between remote_internal driver and libvirtd. Each procedure is
+// identified by a unique number.
+const (
+	// From enums:
+	// QEMUProcDomainMonitorCommand is libvirt's QEMU_PROC_DOMAIN_MONITOR_COMMAND
+	QEMUProcDomainMonitorCommand = 1
+	// QEMUProcDomainAttach is libvirt's QEMU_PROC_DOMAIN_ATTACH
+	QEMUProcDomainAttach = 2
+	// QEMUProcDomainAgentCommand is libvirt's QEMU_PROC_DOMAIN_AGENT_COMMAND
+	QEMUProcDomainAgentCommand = 3
+	// QEMUProcConnectDomainMonitorEventRegister is libvirt's QEMU_PROC_CONNECT_DOMAIN_MONITOR_EVENT_REGISTER
+	QEMUProcConnectDomainMonitorEventRegister = 4
+	// QEMUProcConnectDomainMonitorEventDeregister is libvirt's QEMU_PROC_CONNECT_DOMAIN_MONITOR_EVENT_DEREGISTER
+	QEMUProcConnectDomainMonitorEventDeregister = 5
+	// QEMUProcDomainMonitorEvent is libvirt's QEMU_PROC_DOMAIN_MONITOR_EVENT
+	QEMUProcDomainMonitorEvent = 6
+
+
+	// From consts:
+	// QEMUProgram is libvirt's QEMU_PROGRAM
+	QEMUProgram = 0x20008087
+	// QEMUProtocolVersion is libvirt's QEMU_PROTOCOL_VERSION
+	QEMUProtocolVersion = 1
+)
diff --git a/vendor/github.com/digitalocean/go-libvirt/internal/constants/remote_protocol.gen.go b/vendor/github.com/digitalocean/go-libvirt/internal/constants/remote_protocol.gen.go
new file mode 100644
index 000000000..9b9601cb9
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/internal/constants/remote_protocol.gen.go
@@ -0,0 +1,1019 @@
+// Copyright 2018 The go-libvirt Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//
+// Code generated by internal/lvgen/generate.go. DO NOT EDIT.
+//
+// To regenerate, run 'go generate' in internal/lvgen.
+//
+
+package constants
+
+// These are libvirt procedure numbers which correspond to each respective
+// API call between remote_internal driver and libvirtd. Each procedure is
+// identified by a unique number.
+const (
+	// From enums:
+	// AuthNone is libvirt's REMOTE_AUTH_NONE
+	AuthNone = 0
+	// AuthSasl is libvirt's REMOTE_AUTH_SASL
+	AuthSasl = 1
+	// AuthPolkit is libvirt's REMOTE_AUTH_POLKIT
+	AuthPolkit = 2
+	// ProcConnectOpen is libvirt's REMOTE_PROC_CONNECT_OPEN
+	ProcConnectOpen = 1
+	// ProcConnectClose is libvirt's REMOTE_PROC_CONNECT_CLOSE
+	ProcConnectClose = 2
+	// ProcConnectGetType is libvirt's REMOTE_PROC_CONNECT_GET_TYPE
+	ProcConnectGetType = 3
+	// ProcConnectGetVersion is libvirt's REMOTE_PROC_CONNECT_GET_VERSION
+	ProcConnectGetVersion = 4
+	// ProcConnectGetMaxVcpus is libvirt's REMOTE_PROC_CONNECT_GET_MAX_VCPUS
+	ProcConnectGetMaxVcpus = 5
+	// ProcNodeGetInfo is libvirt's REMOTE_PROC_NODE_GET_INFO
+	ProcNodeGetInfo = 6
+	// ProcConnectGetCapabilities is libvirt's REMOTE_PROC_CONNECT_GET_CAPABILITIES
+	ProcConnectGetCapabilities = 7
+	// ProcDomainAttachDevice is libvirt's REMOTE_PROC_DOMAIN_ATTACH_DEVICE
+	ProcDomainAttachDevice = 8
+	// ProcDomainCreate is libvirt's REMOTE_PROC_DOMAIN_CREATE
+	ProcDomainCreate = 9
+	// ProcDomainCreateXML is libvirt's REMOTE_PROC_DOMAIN_CREATE_XML
+	ProcDomainCreateXML = 10
+	// ProcDomainDefineXML is libvirt's REMOTE_PROC_DOMAIN_DEFINE_XML
+	ProcDomainDefineXML = 11
+	// ProcDomainDestroy is libvirt's REMOTE_PROC_DOMAIN_DESTROY
+	ProcDomainDestroy = 12
+	// ProcDomainDetachDevice is libvirt's REMOTE_PROC_DOMAIN_DETACH_DEVICE
+	ProcDomainDetachDevice = 13
+	// ProcDomainGetXMLDesc is libvirt's REMOTE_PROC_DOMAIN_GET_XML_DESC
+	ProcDomainGetXMLDesc = 14
+	// ProcDomainGetAutostart is libvirt's REMOTE_PROC_DOMAIN_GET_AUTOSTART
+	ProcDomainGetAutostart = 15
+	// ProcDomainGetInfo is libvirt's REMOTE_PROC_DOMAIN_GET_INFO
+	ProcDomainGetInfo = 16
+	// ProcDomainGetMaxMemory is libvirt's REMOTE_PROC_DOMAIN_GET_MAX_MEMORY
+	ProcDomainGetMaxMemory = 17
+	// ProcDomainGetMaxVcpus is libvirt's REMOTE_PROC_DOMAIN_GET_MAX_VCPUS
+	ProcDomainGetMaxVcpus = 18
+	// ProcDomainGetOsType is libvirt's REMOTE_PROC_DOMAIN_GET_OS_TYPE
+	ProcDomainGetOsType = 19
+	// ProcDomainGetVcpus is libvirt's REMOTE_PROC_DOMAIN_GET_VCPUS
+	ProcDomainGetVcpus = 20
+	// ProcConnectListDefinedDomains is libvirt's REMOTE_PROC_CONNECT_LIST_DEFINED_DOMAINS
+	ProcConnectListDefinedDomains = 21
+	// ProcDomainLookupByID is libvirt's REMOTE_PROC_DOMAIN_LOOKUP_BY_ID
+	ProcDomainLookupByID = 22
+	// ProcDomainLookupByName is libvirt's REMOTE_PROC_DOMAIN_LOOKUP_BY_NAME
+	ProcDomainLookupByName = 23
+	// ProcDomainLookupByUUID is libvirt's REMOTE_PROC_DOMAIN_LOOKUP_BY_UUID
+	ProcDomainLookupByUUID = 24
+	// ProcConnectNumOfDefinedDomains is libvirt's REMOTE_PROC_CONNECT_NUM_OF_DEFINED_DOMAINS
+	ProcConnectNumOfDefinedDomains = 25
+	// ProcDomainPinVcpu is libvirt's REMOTE_PROC_DOMAIN_PIN_VCPU
+	ProcDomainPinVcpu = 26
+	// ProcDomainReboot is libvirt's REMOTE_PROC_DOMAIN_REBOOT
+	ProcDomainReboot = 27
+	// ProcDomainResume is libvirt's REMOTE_PROC_DOMAIN_RESUME
+	ProcDomainResume = 28
+	// ProcDomainSetAutostart is libvirt's REMOTE_PROC_DOMAIN_SET_AUTOSTART
+	ProcDomainSetAutostart = 29
+	// ProcDomainSetMaxMemory is libvirt's REMOTE_PROC_DOMAIN_SET_MAX_MEMORY
+	ProcDomainSetMaxMemory = 30
+	// ProcDomainSetMemory is libvirt's REMOTE_PROC_DOMAIN_SET_MEMORY
+	ProcDomainSetMemory = 31
+	// ProcDomainSetVcpus is libvirt's REMOTE_PROC_DOMAIN_SET_VCPUS
+	ProcDomainSetVcpus = 32
+	// ProcDomainShutdown is libvirt's REMOTE_PROC_DOMAIN_SHUTDOWN
+	ProcDomainShutdown = 33
+	// ProcDomainSuspend is libvirt's REMOTE_PROC_DOMAIN_SUSPEND
+	ProcDomainSuspend = 34
+	// ProcDomainUndefine is libvirt's REMOTE_PROC_DOMAIN_UNDEFINE
+	ProcDomainUndefine = 35
+	// ProcConnectListDefinedNetworks is libvirt's REMOTE_PROC_CONNECT_LIST_DEFINED_NETWORKS
+	ProcConnectListDefinedNetworks = 36
+	// ProcConnectListDomains is libvirt's REMOTE_PROC_CONNECT_LIST_DOMAINS
+	ProcConnectListDomains = 37
+	// ProcConnectListNetworks is libvirt's REMOTE_PROC_CONNECT_LIST_NETWORKS
+	ProcConnectListNetworks = 38
+	// ProcNetworkCreate is libvirt's REMOTE_PROC_NETWORK_CREATE
+	ProcNetworkCreate = 39
+	// ProcNetworkCreateXML is libvirt's REMOTE_PROC_NETWORK_CREATE_XML
+	ProcNetworkCreateXML = 40
+	// ProcNetworkDefineXML is libvirt's REMOTE_PROC_NETWORK_DEFINE_XML
+	ProcNetworkDefineXML = 41
+	// ProcNetworkDestroy is libvirt's REMOTE_PROC_NETWORK_DESTROY
+	ProcNetworkDestroy = 42
+	// ProcNetworkGetXMLDesc is libvirt's REMOTE_PROC_NETWORK_GET_XML_DESC
+	ProcNetworkGetXMLDesc = 43
+	// ProcNetworkGetAutostart is libvirt's REMOTE_PROC_NETWORK_GET_AUTOSTART
+	ProcNetworkGetAutostart = 44
+	// ProcNetworkGetBridgeName is libvirt's REMOTE_PROC_NETWORK_GET_BRIDGE_NAME
+	ProcNetworkGetBridgeName = 45
+	// ProcNetworkLookupByName is libvirt's REMOTE_PROC_NETWORK_LOOKUP_BY_NAME
+	ProcNetworkLookupByName = 46
+	// ProcNetworkLookupByUUID is libvirt's REMOTE_PROC_NETWORK_LOOKUP_BY_UUID
+	ProcNetworkLookupByUUID = 47
+	// ProcNetworkSetAutostart is libvirt's REMOTE_PROC_NETWORK_SET_AUTOSTART
+	ProcNetworkSetAutostart = 48
+	// ProcNetworkUndefine is libvirt's REMOTE_PROC_NETWORK_UNDEFINE
+	ProcNetworkUndefine = 49
+	// ProcConnectNumOfDefinedNetworks is libvirt's REMOTE_PROC_CONNECT_NUM_OF_DEFINED_NETWORKS
+	ProcConnectNumOfDefinedNetworks = 50
+	// ProcConnectNumOfDomains is libvirt's REMOTE_PROC_CONNECT_NUM_OF_DOMAINS
+	ProcConnectNumOfDomains = 51
+	// ProcConnectNumOfNetworks is libvirt's REMOTE_PROC_CONNECT_NUM_OF_NETWORKS
+	ProcConnectNumOfNetworks = 52
+	// ProcDomainCoreDump is libvirt's REMOTE_PROC_DOMAIN_CORE_DUMP
+	ProcDomainCoreDump = 53
+	// ProcDomainRestore is libvirt's REMOTE_PROC_DOMAIN_RESTORE
+	ProcDomainRestore = 54
+	// ProcDomainSave is libvirt's REMOTE_PROC_DOMAIN_SAVE
+	ProcDomainSave = 55
+	// ProcDomainGetSchedulerType is libvirt's REMOTE_PROC_DOMAIN_GET_SCHEDULER_TYPE
+	ProcDomainGetSchedulerType = 56
+	// ProcDomainGetSchedulerParameters is libvirt's REMOTE_PROC_DOMAIN_GET_SCHEDULER_PARAMETERS
+	ProcDomainGetSchedulerParameters = 57
+	// ProcDomainSetSchedulerParameters is libvirt's REMOTE_PROC_DOMAIN_SET_SCHEDULER_PARAMETERS
+	ProcDomainSetSchedulerParameters = 58
+	// ProcConnectGetHostname is libvirt's REMOTE_PROC_CONNECT_GET_HOSTNAME
+	ProcConnectGetHostname = 59
+	// ProcConnectSupportsFeature is libvirt's REMOTE_PROC_CONNECT_SUPPORTS_FEATURE
+	ProcConnectSupportsFeature = 60
+	// ProcDomainMigratePrepare is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_PREPARE
+	ProcDomainMigratePrepare = 61
+	// ProcDomainMigratePerform is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_PERFORM
+	ProcDomainMigratePerform = 62
+	// ProcDomainMigrateFinish is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_FINISH
+	ProcDomainMigrateFinish = 63
+	// ProcDomainBlockStats is libvirt's REMOTE_PROC_DOMAIN_BLOCK_STATS
+	ProcDomainBlockStats = 64
+	// ProcDomainInterfaceStats is libvirt's REMOTE_PROC_DOMAIN_INTERFACE_STATS
+	ProcDomainInterfaceStats = 65
+	// ProcAuthList is libvirt's REMOTE_PROC_AUTH_LIST
+	ProcAuthList = 66
+	// ProcAuthSaslInit is libvirt's REMOTE_PROC_AUTH_SASL_INIT
+	ProcAuthSaslInit = 67
+	// ProcAuthSaslStart is libvirt's REMOTE_PROC_AUTH_SASL_START
+	ProcAuthSaslStart = 68
+	// ProcAuthSaslStep is libvirt's REMOTE_PROC_AUTH_SASL_STEP
+	ProcAuthSaslStep = 69
+	// ProcAuthPolkit is libvirt's REMOTE_PROC_AUTH_POLKIT
+	ProcAuthPolkit = 70
+	// ProcConnectNumOfStoragePools is libvirt's REMOTE_PROC_CONNECT_NUM_OF_STORAGE_POOLS
+	ProcConnectNumOfStoragePools = 71
+	// ProcConnectListStoragePools is libvirt's REMOTE_PROC_CONNECT_LIST_STORAGE_POOLS
+	ProcConnectListStoragePools = 72
+	// ProcConnectNumOfDefinedStoragePools is libvirt's REMOTE_PROC_CONNECT_NUM_OF_DEFINED_STORAGE_POOLS
+	ProcConnectNumOfDefinedStoragePools = 73
+	// ProcConnectListDefinedStoragePools is libvirt's REMOTE_PROC_CONNECT_LIST_DEFINED_STORAGE_POOLS
+	ProcConnectListDefinedStoragePools = 74
+	// ProcConnectFindStoragePoolSources is libvirt's REMOTE_PROC_CONNECT_FIND_STORAGE_POOL_SOURCES
+	ProcConnectFindStoragePoolSources = 75
+	// ProcStoragePoolCreateXML is libvirt's REMOTE_PROC_STORAGE_POOL_CREATE_XML
+	ProcStoragePoolCreateXML = 76
+	// ProcStoragePoolDefineXML is libvirt's REMOTE_PROC_STORAGE_POOL_DEFINE_XML
+	ProcStoragePoolDefineXML = 77
+	// ProcStoragePoolCreate is libvirt's REMOTE_PROC_STORAGE_POOL_CREATE
+	ProcStoragePoolCreate = 78
+	// ProcStoragePoolBuild is libvirt's REMOTE_PROC_STORAGE_POOL_BUILD
+	ProcStoragePoolBuild = 79
+	// ProcStoragePoolDestroy is libvirt's REMOTE_PROC_STORAGE_POOL_DESTROY
+	ProcStoragePoolDestroy = 80
+	// ProcStoragePoolDelete is libvirt's REMOTE_PROC_STORAGE_POOL_DELETE
+	ProcStoragePoolDelete = 81
+	// ProcStoragePoolUndefine is libvirt's REMOTE_PROC_STORAGE_POOL_UNDEFINE
+	ProcStoragePoolUndefine = 82
+	// ProcStoragePoolRefresh is libvirt's REMOTE_PROC_STORAGE_POOL_REFRESH
+	ProcStoragePoolRefresh = 83
+	// ProcStoragePoolLookupByName is libvirt's REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_NAME
+	ProcStoragePoolLookupByName = 84
+	// ProcStoragePoolLookupByUUID is libvirt's REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_UUID
+	ProcStoragePoolLookupByUUID = 85
+	// ProcStoragePoolLookupByVolume is libvirt's REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_VOLUME
+	ProcStoragePoolLookupByVolume = 86
+	// ProcStoragePoolGetInfo is libvirt's REMOTE_PROC_STORAGE_POOL_GET_INFO
+	ProcStoragePoolGetInfo = 87
+	// ProcStoragePoolGetXMLDesc is libvirt's REMOTE_PROC_STORAGE_POOL_GET_XML_DESC
+	ProcStoragePoolGetXMLDesc = 88
+	// ProcStoragePoolGetAutostart is libvirt's REMOTE_PROC_STORAGE_POOL_GET_AUTOSTART
+	ProcStoragePoolGetAutostart = 89
+	// ProcStoragePoolSetAutostart is libvirt's REMOTE_PROC_STORAGE_POOL_SET_AUTOSTART
+	ProcStoragePoolSetAutostart = 90
+	// ProcStoragePoolNumOfVolumes is libvirt's REMOTE_PROC_STORAGE_POOL_NUM_OF_VOLUMES
+	ProcStoragePoolNumOfVolumes = 91
+	// ProcStoragePoolListVolumes is libvirt's REMOTE_PROC_STORAGE_POOL_LIST_VOLUMES
+	ProcStoragePoolListVolumes = 92
+	// ProcStorageVolCreateXML is libvirt's REMOTE_PROC_STORAGE_VOL_CREATE_XML
+	ProcStorageVolCreateXML = 93
+	// ProcStorageVolDelete is libvirt's REMOTE_PROC_STORAGE_VOL_DELETE
+	ProcStorageVolDelete = 94
+	// ProcStorageVolLookupByName is libvirt's REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_NAME
+	ProcStorageVolLookupByName = 95
+	// ProcStorageVolLookupByKey is libvirt's REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_KEY
+	ProcStorageVolLookupByKey = 96
+	// ProcStorageVolLookupByPath is libvirt's REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_PATH
+	ProcStorageVolLookupByPath = 97
+	// ProcStorageVolGetInfo is libvirt's REMOTE_PROC_STORAGE_VOL_GET_INFO
+	ProcStorageVolGetInfo = 98
+	// ProcStorageVolGetXMLDesc is libvirt's REMOTE_PROC_STORAGE_VOL_GET_XML_DESC
+	ProcStorageVolGetXMLDesc = 99
+	// ProcStorageVolGetPath is libvirt's REMOTE_PROC_STORAGE_VOL_GET_PATH
+	ProcStorageVolGetPath = 100
+	// ProcNodeGetCellsFreeMemory is libvirt's REMOTE_PROC_NODE_GET_CELLS_FREE_MEMORY
+	ProcNodeGetCellsFreeMemory = 101
+	// ProcNodeGetFreeMemory is libvirt's REMOTE_PROC_NODE_GET_FREE_MEMORY
+	ProcNodeGetFreeMemory = 102
+	// ProcDomainBlockPeek is libvirt's REMOTE_PROC_DOMAIN_BLOCK_PEEK
+	ProcDomainBlockPeek = 103
+	// ProcDomainMemoryPeek is libvirt's REMOTE_PROC_DOMAIN_MEMORY_PEEK
+	ProcDomainMemoryPeek = 104
+	// ProcConnectDomainEventRegister is libvirt's REMOTE_PROC_CONNECT_DOMAIN_EVENT_REGISTER
+	ProcConnectDomainEventRegister = 105
+	// ProcConnectDomainEventDeregister is libvirt's REMOTE_PROC_CONNECT_DOMAIN_EVENT_DEREGISTER
+	ProcConnectDomainEventDeregister = 106
+	// ProcDomainEventLifecycle is libvirt's REMOTE_PROC_DOMAIN_EVENT_LIFECYCLE
+	ProcDomainEventLifecycle = 107
+	// ProcDomainMigratePrepare2 is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_PREPARE2
+	ProcDomainMigratePrepare2 = 108
+	// ProcDomainMigrateFinish2 is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_FINISH2
+	ProcDomainMigrateFinish2 = 109
+	// ProcConnectGetUri is libvirt's REMOTE_PROC_CONNECT_GET_URI
+	ProcConnectGetUri = 110
+	// ProcNodeNumOfDevices is libvirt's REMOTE_PROC_NODE_NUM_OF_DEVICES
+	ProcNodeNumOfDevices = 111
+	// ProcNodeListDevices is libvirt's REMOTE_PROC_NODE_LIST_DEVICES
+	ProcNodeListDevices = 112
+	// ProcNodeDeviceLookupByName is libvirt's REMOTE_PROC_NODE_DEVICE_LOOKUP_BY_NAME
+	ProcNodeDeviceLookupByName = 113
+	// ProcNodeDeviceGetXMLDesc is libvirt's REMOTE_PROC_NODE_DEVICE_GET_XML_DESC
+	ProcNodeDeviceGetXMLDesc = 114
+	// ProcNodeDeviceGetParent is libvirt's REMOTE_PROC_NODE_DEVICE_GET_PARENT
+	ProcNodeDeviceGetParent = 115
+	// ProcNodeDeviceNumOfCaps is libvirt's REMOTE_PROC_NODE_DEVICE_NUM_OF_CAPS
+	ProcNodeDeviceNumOfCaps = 116
+	// ProcNodeDeviceListCaps is libvirt's REMOTE_PROC_NODE_DEVICE_LIST_CAPS
+	ProcNodeDeviceListCaps = 117
+	// ProcNodeDeviceDettach is libvirt's REMOTE_PROC_NODE_DEVICE_DETTACH
+	ProcNodeDeviceDettach = 118
+	// ProcNodeDeviceReAttach is libvirt's REMOTE_PROC_NODE_DEVICE_RE_ATTACH
+	ProcNodeDeviceReAttach = 119
+	// ProcNodeDeviceReset is libvirt's REMOTE_PROC_NODE_DEVICE_RESET
+	ProcNodeDeviceReset = 120
+	// ProcDomainGetSecurityLabel is libvirt's REMOTE_PROC_DOMAIN_GET_SECURITY_LABEL
+	ProcDomainGetSecurityLabel = 121
+	// ProcNodeGetSecurityModel is libvirt's REMOTE_PROC_NODE_GET_SECURITY_MODEL
+	ProcNodeGetSecurityModel = 122
+	// ProcNodeDeviceCreateXML is libvirt's REMOTE_PROC_NODE_DEVICE_CREATE_XML
+	ProcNodeDeviceCreateXML = 123
+	// ProcNodeDeviceDestroy is libvirt's REMOTE_PROC_NODE_DEVICE_DESTROY
+	ProcNodeDeviceDestroy = 124
+	// ProcStorageVolCreateXMLFrom is libvirt's REMOTE_PROC_STORAGE_VOL_CREATE_XML_FROM
+	ProcStorageVolCreateXMLFrom = 125
+	// ProcConnectNumOfInterfaces is libvirt's REMOTE_PROC_CONNECT_NUM_OF_INTERFACES
+	ProcConnectNumOfInterfaces = 126
+	// ProcConnectListInterfaces is libvirt's REMOTE_PROC_CONNECT_LIST_INTERFACES
+	ProcConnectListInterfaces = 127
+	// ProcInterfaceLookupByName is libvirt's REMOTE_PROC_INTERFACE_LOOKUP_BY_NAME
+	ProcInterfaceLookupByName = 128
+	// ProcInterfaceLookupByMacString is libvirt's REMOTE_PROC_INTERFACE_LOOKUP_BY_MAC_STRING
+	ProcInterfaceLookupByMacString = 129
+	// ProcInterfaceGetXMLDesc is libvirt's REMOTE_PROC_INTERFACE_GET_XML_DESC
+	ProcInterfaceGetXMLDesc = 130
+	// ProcInterfaceDefineXML is libvirt's REMOTE_PROC_INTERFACE_DEFINE_XML
+	ProcInterfaceDefineXML = 131
+	// ProcInterfaceUndefine is libvirt's REMOTE_PROC_INTERFACE_UNDEFINE
+	ProcInterfaceUndefine = 132
+	// ProcInterfaceCreate is libvirt's REMOTE_PROC_INTERFACE_CREATE
+	ProcInterfaceCreate = 133
+	// ProcInterfaceDestroy is libvirt's REMOTE_PROC_INTERFACE_DESTROY
+	ProcInterfaceDestroy = 134
+	// ProcConnectDomainXMLFromNative is libvirt's REMOTE_PROC_CONNECT_DOMAIN_XML_FROM_NATIVE
+	ProcConnectDomainXMLFromNative = 135
+	// ProcConnectDomainXMLToNative is libvirt's REMOTE_PROC_CONNECT_DOMAIN_XML_TO_NATIVE
+	ProcConnectDomainXMLToNative = 136
+	// ProcConnectNumOfDefinedInterfaces is libvirt's REMOTE_PROC_CONNECT_NUM_OF_DEFINED_INTERFACES
+	ProcConnectNumOfDefinedInterfaces = 137
+	// ProcConnectListDefinedInterfaces is libvirt's REMOTE_PROC_CONNECT_LIST_DEFINED_INTERFACES
+	ProcConnectListDefinedInterfaces = 138
+	// ProcConnectNumOfSecrets is libvirt's REMOTE_PROC_CONNECT_NUM_OF_SECRETS
+	ProcConnectNumOfSecrets = 139
+	// ProcConnectListSecrets is libvirt's REMOTE_PROC_CONNECT_LIST_SECRETS
+	ProcConnectListSecrets = 140
+	// ProcSecretLookupByUUID is libvirt's REMOTE_PROC_SECRET_LOOKUP_BY_UUID
+	ProcSecretLookupByUUID = 141
+	// ProcSecretDefineXML is libvirt's REMOTE_PROC_SECRET_DEFINE_XML
+	ProcSecretDefineXML = 142
+	// ProcSecretGetXMLDesc is libvirt's REMOTE_PROC_SECRET_GET_XML_DESC
+	ProcSecretGetXMLDesc = 143
+	// ProcSecretSetValue is libvirt's REMOTE_PROC_SECRET_SET_VALUE
+	ProcSecretSetValue = 144
+	// ProcSecretGetValue is libvirt's REMOTE_PROC_SECRET_GET_VALUE
+	ProcSecretGetValue = 145
+	// ProcSecretUndefine is libvirt's REMOTE_PROC_SECRET_UNDEFINE
+	ProcSecretUndefine = 146
+	// ProcSecretLookupByUsage is libvirt's REMOTE_PROC_SECRET_LOOKUP_BY_USAGE
+	ProcSecretLookupByUsage = 147
+	// ProcDomainMigratePrepareTunnel is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL
+	ProcDomainMigratePrepareTunnel = 148
+	// ProcConnectIsSecure is libvirt's REMOTE_PROC_CONNECT_IS_SECURE
+	ProcConnectIsSecure = 149
+	// ProcDomainIsActive is libvirt's REMOTE_PROC_DOMAIN_IS_ACTIVE
+	ProcDomainIsActive = 150
+	// ProcDomainIsPersistent is libvirt's REMOTE_PROC_DOMAIN_IS_PERSISTENT
+	ProcDomainIsPersistent = 151
+	// ProcNetworkIsActive is libvirt's REMOTE_PROC_NETWORK_IS_ACTIVE
+	ProcNetworkIsActive = 152
+	// ProcNetworkIsPersistent is libvirt's REMOTE_PROC_NETWORK_IS_PERSISTENT
+	ProcNetworkIsPersistent = 153
+	// ProcStoragePoolIsActive is libvirt's REMOTE_PROC_STORAGE_POOL_IS_ACTIVE
+	ProcStoragePoolIsActive = 154
+	// ProcStoragePoolIsPersistent is libvirt's REMOTE_PROC_STORAGE_POOL_IS_PERSISTENT
+	ProcStoragePoolIsPersistent = 155
+	// ProcInterfaceIsActive is libvirt's REMOTE_PROC_INTERFACE_IS_ACTIVE
+	ProcInterfaceIsActive = 156
+	// ProcConnectGetLibVersion is libvirt's REMOTE_PROC_CONNECT_GET_LIB_VERSION
+	ProcConnectGetLibVersion = 157
+	// ProcConnectCompareCPU is libvirt's REMOTE_PROC_CONNECT_COMPARE_CPU
+	ProcConnectCompareCPU = 158
+	// ProcDomainMemoryStats is libvirt's REMOTE_PROC_DOMAIN_MEMORY_STATS
+	ProcDomainMemoryStats = 159
+	// ProcDomainAttachDeviceFlags is libvirt's REMOTE_PROC_DOMAIN_ATTACH_DEVICE_FLAGS
+	ProcDomainAttachDeviceFlags = 160
+	// ProcDomainDetachDeviceFlags is libvirt's REMOTE_PROC_DOMAIN_DETACH_DEVICE_FLAGS
+	ProcDomainDetachDeviceFlags = 161
+	// ProcConnectBaselineCPU is libvirt's REMOTE_PROC_CONNECT_BASELINE_CPU
+	ProcConnectBaselineCPU = 162
+	// ProcDomainGetJobInfo is libvirt's REMOTE_PROC_DOMAIN_GET_JOB_INFO
+	ProcDomainGetJobInfo = 163
+	// ProcDomainAbortJob is libvirt's REMOTE_PROC_DOMAIN_ABORT_JOB
+	ProcDomainAbortJob = 164
+	// ProcStorageVolWipe is libvirt's REMOTE_PROC_STORAGE_VOL_WIPE
+	ProcStorageVolWipe = 165
+	// ProcDomainMigrateSetMaxDowntime is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_SET_MAX_DOWNTIME
+	ProcDomainMigrateSetMaxDowntime = 166
+	// ProcConnectDomainEventRegisterAny is libvirt's REMOTE_PROC_CONNECT_DOMAIN_EVENT_REGISTER_ANY
+	ProcConnectDomainEventRegisterAny = 167
+	// ProcConnectDomainEventDeregisterAny is libvirt's REMOTE_PROC_CONNECT_DOMAIN_EVENT_DEREGISTER_ANY
+	ProcConnectDomainEventDeregisterAny = 168
+	// ProcDomainEventReboot is libvirt's REMOTE_PROC_DOMAIN_EVENT_REBOOT
+	ProcDomainEventReboot = 169
+	// ProcDomainEventRtcChange is libvirt's REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE
+	ProcDomainEventRtcChange = 170
+	// ProcDomainEventWatchdog is libvirt's REMOTE_PROC_DOMAIN_EVENT_WATCHDOG
+	ProcDomainEventWatchdog = 171
+	// ProcDomainEventIOError is libvirt's REMOTE_PROC_DOMAIN_EVENT_IO_ERROR
+	ProcDomainEventIOError = 172
+	// ProcDomainEventGraphics is libvirt's REMOTE_PROC_DOMAIN_EVENT_GRAPHICS
+	ProcDomainEventGraphics = 173
+	// ProcDomainUpdateDeviceFlags is libvirt's REMOTE_PROC_DOMAIN_UPDATE_DEVICE_FLAGS
+	ProcDomainUpdateDeviceFlags = 174
+	// ProcNwfilterLookupByName is libvirt's REMOTE_PROC_NWFILTER_LOOKUP_BY_NAME
+	ProcNwfilterLookupByName = 175
+	// ProcNwfilterLookupByUUID is libvirt's REMOTE_PROC_NWFILTER_LOOKUP_BY_UUID
+	ProcNwfilterLookupByUUID = 176
+	// ProcNwfilterGetXMLDesc is libvirt's REMOTE_PROC_NWFILTER_GET_XML_DESC
+	ProcNwfilterGetXMLDesc = 177
+	// ProcConnectNumOfNwfilters is libvirt's REMOTE_PROC_CONNECT_NUM_OF_NWFILTERS
+	ProcConnectNumOfNwfilters = 178
+	// ProcConnectListNwfilters is libvirt's REMOTE_PROC_CONNECT_LIST_NWFILTERS
+	ProcConnectListNwfilters = 179
+	// ProcNwfilterDefineXML is libvirt's REMOTE_PROC_NWFILTER_DEFINE_XML
+	ProcNwfilterDefineXML = 180
+	// ProcNwfilterUndefine is libvirt's REMOTE_PROC_NWFILTER_UNDEFINE
+	ProcNwfilterUndefine = 181
+	// ProcDomainManagedSave is libvirt's REMOTE_PROC_DOMAIN_MANAGED_SAVE
+	ProcDomainManagedSave = 182
+	// ProcDomainHasManagedSaveImage is libvirt's REMOTE_PROC_DOMAIN_HAS_MANAGED_SAVE_IMAGE
+	ProcDomainHasManagedSaveImage = 183
+	// ProcDomainManagedSaveRemove is libvirt's REMOTE_PROC_DOMAIN_MANAGED_SAVE_REMOVE
+	ProcDomainManagedSaveRemove = 184
+	// ProcDomainSnapshotCreateXML is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_CREATE_XML
+	ProcDomainSnapshotCreateXML = 185
+	// ProcDomainSnapshotGetXMLDesc is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_GET_XML_DESC
+	ProcDomainSnapshotGetXMLDesc = 186
+	// ProcDomainSnapshotNum is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_NUM
+	ProcDomainSnapshotNum = 187
+	// ProcDomainSnapshotListNames is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_NAMES
+	ProcDomainSnapshotListNames = 188
+	// ProcDomainSnapshotLookupByName is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_LOOKUP_BY_NAME
+	ProcDomainSnapshotLookupByName = 189
+	// ProcDomainHasCurrentSnapshot is libvirt's REMOTE_PROC_DOMAIN_HAS_CURRENT_SNAPSHOT
+	ProcDomainHasCurrentSnapshot = 190
+	// ProcDomainSnapshotCurrent is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_CURRENT
+	ProcDomainSnapshotCurrent = 191
+	// ProcDomainRevertToSnapshot is libvirt's REMOTE_PROC_DOMAIN_REVERT_TO_SNAPSHOT
+	ProcDomainRevertToSnapshot = 192
+	// ProcDomainSnapshotDelete is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_DELETE
+	ProcDomainSnapshotDelete = 193
+	// ProcDomainGetBlockInfo is libvirt's REMOTE_PROC_DOMAIN_GET_BLOCK_INFO
+	ProcDomainGetBlockInfo = 194
+	// ProcDomainEventIOErrorReason is libvirt's REMOTE_PROC_DOMAIN_EVENT_IO_ERROR_REASON
+	ProcDomainEventIOErrorReason = 195
+	// ProcDomainCreateWithFlags is libvirt's REMOTE_PROC_DOMAIN_CREATE_WITH_FLAGS
+	ProcDomainCreateWithFlags = 196
+	// ProcDomainSetMemoryParameters is libvirt's REMOTE_PROC_DOMAIN_SET_MEMORY_PARAMETERS
+	ProcDomainSetMemoryParameters = 197
+	// ProcDomainGetMemoryParameters is libvirt's REMOTE_PROC_DOMAIN_GET_MEMORY_PARAMETERS
+	ProcDomainGetMemoryParameters = 198
+	// ProcDomainSetVcpusFlags is libvirt's REMOTE_PROC_DOMAIN_SET_VCPUS_FLAGS
+	ProcDomainSetVcpusFlags = 199
+	// ProcDomainGetVcpusFlags is libvirt's REMOTE_PROC_DOMAIN_GET_VCPUS_FLAGS
+	ProcDomainGetVcpusFlags = 200
+	// ProcDomainOpenConsole is libvirt's REMOTE_PROC_DOMAIN_OPEN_CONSOLE
+	ProcDomainOpenConsole = 201
+	// ProcDomainIsUpdated is libvirt's REMOTE_PROC_DOMAIN_IS_UPDATED
+	ProcDomainIsUpdated = 202
+	// ProcConnectGetSysinfo is libvirt's REMOTE_PROC_CONNECT_GET_SYSINFO
+	ProcConnectGetSysinfo = 203
+	// ProcDomainSetMemoryFlags is libvirt's REMOTE_PROC_DOMAIN_SET_MEMORY_FLAGS
+	ProcDomainSetMemoryFlags = 204
+	// ProcDomainSetBlkioParameters is libvirt's REMOTE_PROC_DOMAIN_SET_BLKIO_PARAMETERS
+	ProcDomainSetBlkioParameters = 205
+	// ProcDomainGetBlkioParameters is libvirt's REMOTE_PROC_DOMAIN_GET_BLKIO_PARAMETERS
+	ProcDomainGetBlkioParameters = 206
+	// ProcDomainMigrateSetMaxSpeed is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_SET_MAX_SPEED
+	ProcDomainMigrateSetMaxSpeed = 207
+	// ProcStorageVolUpload is libvirt's REMOTE_PROC_STORAGE_VOL_UPLOAD
+	ProcStorageVolUpload = 208
+	// ProcStorageVolDownload is libvirt's REMOTE_PROC_STORAGE_VOL_DOWNLOAD
+	ProcStorageVolDownload = 209
+	// ProcDomainInjectNmi is libvirt's REMOTE_PROC_DOMAIN_INJECT_NMI
+	ProcDomainInjectNmi = 210
+	// ProcDomainScreenshot is libvirt's REMOTE_PROC_DOMAIN_SCREENSHOT
+	ProcDomainScreenshot = 211
+	// ProcDomainGetState is libvirt's REMOTE_PROC_DOMAIN_GET_STATE
+	ProcDomainGetState = 212
+	// ProcDomainMigrateBegin3 is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_BEGIN3
+	ProcDomainMigrateBegin3 = 213
+	// ProcDomainMigratePrepare3 is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_PREPARE3
+	ProcDomainMigratePrepare3 = 214
+	// ProcDomainMigratePrepareTunnel3 is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL3
+	ProcDomainMigratePrepareTunnel3 = 215
+	// ProcDomainMigratePerform3 is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_PERFORM3
+	ProcDomainMigratePerform3 = 216
+	// ProcDomainMigrateFinish3 is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_FINISH3
+	ProcDomainMigrateFinish3 = 217
+	// ProcDomainMigrateConfirm3 is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_CONFIRM3
+	ProcDomainMigrateConfirm3 = 218
+	// ProcDomainSetSchedulerParametersFlags is libvirt's REMOTE_PROC_DOMAIN_SET_SCHEDULER_PARAMETERS_FLAGS
+	ProcDomainSetSchedulerParametersFlags = 219
+	// ProcInterfaceChangeBegin is libvirt's REMOTE_PROC_INTERFACE_CHANGE_BEGIN
+	ProcInterfaceChangeBegin = 220
+	// ProcInterfaceChangeCommit is libvirt's REMOTE_PROC_INTERFACE_CHANGE_COMMIT
+	ProcInterfaceChangeCommit = 221
+	// ProcInterfaceChangeRollback is libvirt's REMOTE_PROC_INTERFACE_CHANGE_ROLLBACK
+	ProcInterfaceChangeRollback = 222
+	// ProcDomainGetSchedulerParametersFlags is libvirt's REMOTE_PROC_DOMAIN_GET_SCHEDULER_PARAMETERS_FLAGS
+	ProcDomainGetSchedulerParametersFlags = 223
+	// ProcDomainEventControlError is libvirt's REMOTE_PROC_DOMAIN_EVENT_CONTROL_ERROR
+	ProcDomainEventControlError = 224
+	// ProcDomainPinVcpuFlags is libvirt's REMOTE_PROC_DOMAIN_PIN_VCPU_FLAGS
+	ProcDomainPinVcpuFlags = 225
+	// ProcDomainSendKey is libvirt's REMOTE_PROC_DOMAIN_SEND_KEY
+	ProcDomainSendKey = 226
+	// ProcNodeGetCPUStats is libvirt's REMOTE_PROC_NODE_GET_CPU_STATS
+	ProcNodeGetCPUStats = 227
+	// ProcNodeGetMemoryStats is libvirt's REMOTE_PROC_NODE_GET_MEMORY_STATS
+	ProcNodeGetMemoryStats = 228
+	// ProcDomainGetControlInfo is libvirt's REMOTE_PROC_DOMAIN_GET_CONTROL_INFO
+	ProcDomainGetControlInfo = 229
+	// ProcDomainGetVcpuPinInfo is libvirt's REMOTE_PROC_DOMAIN_GET_VCPU_PIN_INFO
+	ProcDomainGetVcpuPinInfo = 230
+	// ProcDomainUndefineFlags is libvirt's REMOTE_PROC_DOMAIN_UNDEFINE_FLAGS
+	ProcDomainUndefineFlags = 231
+	// ProcDomainSaveFlags is libvirt's REMOTE_PROC_DOMAIN_SAVE_FLAGS
+	ProcDomainSaveFlags = 232
+	// ProcDomainRestoreFlags is libvirt's REMOTE_PROC_DOMAIN_RESTORE_FLAGS
+	ProcDomainRestoreFlags = 233
+	// ProcDomainDestroyFlags is libvirt's REMOTE_PROC_DOMAIN_DESTROY_FLAGS
+	ProcDomainDestroyFlags = 234
+	// ProcDomainSaveImageGetXMLDesc is libvirt's REMOTE_PROC_DOMAIN_SAVE_IMAGE_GET_XML_DESC
+	ProcDomainSaveImageGetXMLDesc = 235
+	// ProcDomainSaveImageDefineXML is libvirt's REMOTE_PROC_DOMAIN_SAVE_IMAGE_DEFINE_XML
+	ProcDomainSaveImageDefineXML = 236
+	// ProcDomainBlockJobAbort is libvirt's REMOTE_PROC_DOMAIN_BLOCK_JOB_ABORT
+	ProcDomainBlockJobAbort = 237
+	// ProcDomainGetBlockJobInfo is libvirt's REMOTE_PROC_DOMAIN_GET_BLOCK_JOB_INFO
+	ProcDomainGetBlockJobInfo = 238
+	// ProcDomainBlockJobSetSpeed is libvirt's REMOTE_PROC_DOMAIN_BLOCK_JOB_SET_SPEED
+	ProcDomainBlockJobSetSpeed = 239
+	// ProcDomainBlockPull is libvirt's REMOTE_PROC_DOMAIN_BLOCK_PULL
+	ProcDomainBlockPull = 240
+	// ProcDomainEventBlockJob is libvirt's REMOTE_PROC_DOMAIN_EVENT_BLOCK_JOB
+	ProcDomainEventBlockJob = 241
+	// ProcDomainMigrateGetMaxSpeed is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_GET_MAX_SPEED
+	ProcDomainMigrateGetMaxSpeed = 242
+	// ProcDomainBlockStatsFlags is libvirt's REMOTE_PROC_DOMAIN_BLOCK_STATS_FLAGS
+	ProcDomainBlockStatsFlags = 243
+	// ProcDomainSnapshotGetParent is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_GET_PARENT
+	ProcDomainSnapshotGetParent = 244
+	// ProcDomainReset is libvirt's REMOTE_PROC_DOMAIN_RESET
+	ProcDomainReset = 245
+	// ProcDomainSnapshotNumChildren is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_NUM_CHILDREN
+	ProcDomainSnapshotNumChildren = 246
+	// ProcDomainSnapshotListChildrenNames is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_CHILDREN_NAMES
+	ProcDomainSnapshotListChildrenNames = 247
+	// ProcDomainEventDiskChange is libvirt's REMOTE_PROC_DOMAIN_EVENT_DISK_CHANGE
+	ProcDomainEventDiskChange = 248
+	// ProcDomainOpenGraphics is libvirt's REMOTE_PROC_DOMAIN_OPEN_GRAPHICS
+	ProcDomainOpenGraphics = 249
+	// ProcNodeSuspendForDuration is libvirt's REMOTE_PROC_NODE_SUSPEND_FOR_DURATION
+	ProcNodeSuspendForDuration = 250
+	// ProcDomainBlockResize is libvirt's REMOTE_PROC_DOMAIN_BLOCK_RESIZE
+	ProcDomainBlockResize = 251
+	// ProcDomainSetBlockIOTune is libvirt's REMOTE_PROC_DOMAIN_SET_BLOCK_IO_TUNE
+	ProcDomainSetBlockIOTune = 252
+	// ProcDomainGetBlockIOTune is libvirt's REMOTE_PROC_DOMAIN_GET_BLOCK_IO_TUNE
+	ProcDomainGetBlockIOTune = 253
+	// ProcDomainSetNumaParameters is libvirt's REMOTE_PROC_DOMAIN_SET_NUMA_PARAMETERS
+	ProcDomainSetNumaParameters = 254
+	// ProcDomainGetNumaParameters is libvirt's REMOTE_PROC_DOMAIN_GET_NUMA_PARAMETERS
+	ProcDomainGetNumaParameters = 255
+	// ProcDomainSetInterfaceParameters is libvirt's REMOTE_PROC_DOMAIN_SET_INTERFACE_PARAMETERS
+	ProcDomainSetInterfaceParameters = 256
+	// ProcDomainGetInterfaceParameters is libvirt's REMOTE_PROC_DOMAIN_GET_INTERFACE_PARAMETERS
+	ProcDomainGetInterfaceParameters = 257
+	// ProcDomainShutdownFlags is libvirt's REMOTE_PROC_DOMAIN_SHUTDOWN_FLAGS
+	ProcDomainShutdownFlags = 258
+	// ProcStorageVolWipePattern is libvirt's REMOTE_PROC_STORAGE_VOL_WIPE_PATTERN
+	ProcStorageVolWipePattern = 259
+	// ProcStorageVolResize is libvirt's REMOTE_PROC_STORAGE_VOL_RESIZE
+	ProcStorageVolResize = 260
+	// ProcDomainPmSuspendForDuration is libvirt's REMOTE_PROC_DOMAIN_PM_SUSPEND_FOR_DURATION
+	ProcDomainPmSuspendForDuration = 261
+	// ProcDomainGetCPUStats is libvirt's REMOTE_PROC_DOMAIN_GET_CPU_STATS
+	ProcDomainGetCPUStats = 262
+	// ProcDomainGetDiskErrors is libvirt's REMOTE_PROC_DOMAIN_GET_DISK_ERRORS
+	ProcDomainGetDiskErrors = 263
+	// ProcDomainSetMetadata is libvirt's REMOTE_PROC_DOMAIN_SET_METADATA
+	ProcDomainSetMetadata = 264
+	// ProcDomainGetMetadata is libvirt's REMOTE_PROC_DOMAIN_GET_METADATA
+	ProcDomainGetMetadata = 265
+	// ProcDomainBlockRebase is libvirt's REMOTE_PROC_DOMAIN_BLOCK_REBASE
+	ProcDomainBlockRebase = 266
+	// ProcDomainPmWakeup is libvirt's REMOTE_PROC_DOMAIN_PM_WAKEUP
+	ProcDomainPmWakeup = 267
+	// ProcDomainEventTrayChange is libvirt's REMOTE_PROC_DOMAIN_EVENT_TRAY_CHANGE
+	ProcDomainEventTrayChange = 268
+	// ProcDomainEventPmwakeup is libvirt's REMOTE_PROC_DOMAIN_EVENT_PMWAKEUP
+	ProcDomainEventPmwakeup = 269
+	// ProcDomainEventPmsuspend is libvirt's REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND
+	ProcDomainEventPmsuspend = 270
+	// ProcDomainSnapshotIsCurrent is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_IS_CURRENT
+	ProcDomainSnapshotIsCurrent = 271
+	// ProcDomainSnapshotHasMetadata is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_HAS_METADATA
+	ProcDomainSnapshotHasMetadata = 272
+	// ProcConnectListAllDomains is libvirt's REMOTE_PROC_CONNECT_LIST_ALL_DOMAINS
+	ProcConnectListAllDomains = 273
+	// ProcDomainListAllSnapshots is libvirt's REMOTE_PROC_DOMAIN_LIST_ALL_SNAPSHOTS
+	ProcDomainListAllSnapshots = 274
+	// ProcDomainSnapshotListAllChildren is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_ALL_CHILDREN
+	ProcDomainSnapshotListAllChildren = 275
+	// ProcDomainEventBalloonChange is libvirt's REMOTE_PROC_DOMAIN_EVENT_BALLOON_CHANGE
+	ProcDomainEventBalloonChange = 276
+	// ProcDomainGetHostname is libvirt's REMOTE_PROC_DOMAIN_GET_HOSTNAME
+	ProcDomainGetHostname = 277
+	// ProcDomainGetSecurityLabelList is libvirt's REMOTE_PROC_DOMAIN_GET_SECURITY_LABEL_LIST
+	ProcDomainGetSecurityLabelList = 278
+	// ProcDomainPinEmulator is libvirt's REMOTE_PROC_DOMAIN_PIN_EMULATOR
+	ProcDomainPinEmulator = 279
+	// ProcDomainGetEmulatorPinInfo is libvirt's REMOTE_PROC_DOMAIN_GET_EMULATOR_PIN_INFO
+	ProcDomainGetEmulatorPinInfo = 280
+	// ProcConnectListAllStoragePools is libvirt's REMOTE_PROC_CONNECT_LIST_ALL_STORAGE_POOLS
+	ProcConnectListAllStoragePools = 281
+	// ProcStoragePoolListAllVolumes is libvirt's REMOTE_PROC_STORAGE_POOL_LIST_ALL_VOLUMES
+	ProcStoragePoolListAllVolumes = 282
+	// ProcConnectListAllNetworks is libvirt's REMOTE_PROC_CONNECT_LIST_ALL_NETWORKS
+	ProcConnectListAllNetworks = 283
+	// ProcConnectListAllInterfaces is libvirt's REMOTE_PROC_CONNECT_LIST_ALL_INTERFACES
+	ProcConnectListAllInterfaces = 284
+	// ProcConnectListAllNodeDevices is libvirt's REMOTE_PROC_CONNECT_LIST_ALL_NODE_DEVICES
+	ProcConnectListAllNodeDevices = 285
+	// ProcConnectListAllNwfilters is libvirt's REMOTE_PROC_CONNECT_LIST_ALL_NWFILTERS
+	ProcConnectListAllNwfilters = 286
+	// ProcConnectListAllSecrets is libvirt's REMOTE_PROC_CONNECT_LIST_ALL_SECRETS
+	ProcConnectListAllSecrets = 287
+	// ProcNodeSetMemoryParameters is libvirt's REMOTE_PROC_NODE_SET_MEMORY_PARAMETERS
+	ProcNodeSetMemoryParameters = 288
+	// ProcNodeGetMemoryParameters is libvirt's REMOTE_PROC_NODE_GET_MEMORY_PARAMETERS
+	ProcNodeGetMemoryParameters = 289
+	// ProcDomainBlockCommit is libvirt's REMOTE_PROC_DOMAIN_BLOCK_COMMIT
+	ProcDomainBlockCommit = 290
+	// ProcNetworkUpdate is libvirt's REMOTE_PROC_NETWORK_UPDATE
+	ProcNetworkUpdate = 291
+	// ProcDomainEventPmsuspendDisk is libvirt's REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND_DISK
+	ProcDomainEventPmsuspendDisk = 292
+	// ProcNodeGetCPUMap is libvirt's REMOTE_PROC_NODE_GET_CPU_MAP
+	ProcNodeGetCPUMap = 293
+	// ProcDomainFstrim is libvirt's REMOTE_PROC_DOMAIN_FSTRIM
+	ProcDomainFstrim = 294
+	// ProcDomainSendProcessSignal is libvirt's REMOTE_PROC_DOMAIN_SEND_PROCESS_SIGNAL
+	ProcDomainSendProcessSignal = 295
+	// ProcDomainOpenChannel is libvirt's REMOTE_PROC_DOMAIN_OPEN_CHANNEL
+	ProcDomainOpenChannel = 296
+	// ProcNodeDeviceLookupScsiHostByWwn is libvirt's REMOTE_PROC_NODE_DEVICE_LOOKUP_SCSI_HOST_BY_WWN
+	ProcNodeDeviceLookupScsiHostByWwn = 297
+	// ProcDomainGetJobStats is libvirt's REMOTE_PROC_DOMAIN_GET_JOB_STATS
+	ProcDomainGetJobStats = 298
+	// ProcDomainMigrateGetCompressionCache is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_GET_COMPRESSION_CACHE
+	ProcDomainMigrateGetCompressionCache = 299
+	// ProcDomainMigrateSetCompressionCache is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_SET_COMPRESSION_CACHE
+	ProcDomainMigrateSetCompressionCache = 300
+	// ProcNodeDeviceDetachFlags is libvirt's REMOTE_PROC_NODE_DEVICE_DETACH_FLAGS
+	ProcNodeDeviceDetachFlags = 301
+	// ProcDomainMigrateBegin3Params is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_BEGIN3_PARAMS
+	ProcDomainMigrateBegin3Params = 302
+	// ProcDomainMigratePrepare3Params is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_PREPARE3_PARAMS
+	ProcDomainMigratePrepare3Params = 303
+	// ProcDomainMigratePrepareTunnel3Params is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL3_PARAMS
+	ProcDomainMigratePrepareTunnel3Params = 304
+	// ProcDomainMigratePerform3Params is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_PERFORM3_PARAMS
+	ProcDomainMigratePerform3Params = 305
+	// ProcDomainMigrateFinish3Params is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_FINISH3_PARAMS
+	ProcDomainMigrateFinish3Params = 306
+	// ProcDomainMigrateConfirm3Params is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_CONFIRM3_PARAMS
+	ProcDomainMigrateConfirm3Params = 307
+	// ProcDomainSetMemoryStatsPeriod is libvirt's REMOTE_PROC_DOMAIN_SET_MEMORY_STATS_PERIOD
+	ProcDomainSetMemoryStatsPeriod = 308
+	// ProcDomainCreateXMLWithFiles is libvirt's REMOTE_PROC_DOMAIN_CREATE_XML_WITH_FILES
+	ProcDomainCreateXMLWithFiles = 309
+	// ProcDomainCreateWithFiles is libvirt's REMOTE_PROC_DOMAIN_CREATE_WITH_FILES
+	ProcDomainCreateWithFiles = 310
+	// ProcDomainEventDeviceRemoved is libvirt's REMOTE_PROC_DOMAIN_EVENT_DEVICE_REMOVED
+	ProcDomainEventDeviceRemoved = 311
+	// ProcConnectGetCPUModelNames is libvirt's REMOTE_PROC_CONNECT_GET_CPU_MODEL_NAMES
+	ProcConnectGetCPUModelNames = 312
+	// ProcConnectNetworkEventRegisterAny is libvirt's REMOTE_PROC_CONNECT_NETWORK_EVENT_REGISTER_ANY
+	ProcConnectNetworkEventRegisterAny = 313
+	// ProcConnectNetworkEventDeregisterAny is libvirt's REMOTE_PROC_CONNECT_NETWORK_EVENT_DEREGISTER_ANY
+	ProcConnectNetworkEventDeregisterAny = 314
+	// ProcNetworkEventLifecycle is libvirt's REMOTE_PROC_NETWORK_EVENT_LIFECYCLE
+	ProcNetworkEventLifecycle = 315
+	// ProcConnectDomainEventCallbackRegisterAny is libvirt's REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_REGISTER_ANY
+	ProcConnectDomainEventCallbackRegisterAny = 316
+	// ProcConnectDomainEventCallbackDeregisterAny is libvirt's REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_DEREGISTER_ANY
+	ProcConnectDomainEventCallbackDeregisterAny = 317
+	// ProcDomainEventCallbackLifecycle is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_LIFECYCLE
+	ProcDomainEventCallbackLifecycle = 318
+	// ProcDomainEventCallbackReboot is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_REBOOT
+	ProcDomainEventCallbackReboot = 319
+	// ProcDomainEventCallbackRtcChange is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_RTC_CHANGE
+	ProcDomainEventCallbackRtcChange = 320
+	// ProcDomainEventCallbackWatchdog is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_WATCHDOG
+	ProcDomainEventCallbackWatchdog = 321
+	// ProcDomainEventCallbackIOError is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR
+	ProcDomainEventCallbackIOError = 322
+	// ProcDomainEventCallbackGraphics is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_GRAPHICS
+	ProcDomainEventCallbackGraphics = 323
+	// ProcDomainEventCallbackIOErrorReason is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR_REASON
+	ProcDomainEventCallbackIOErrorReason = 324
+	// ProcDomainEventCallbackControlError is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_CONTROL_ERROR
+	ProcDomainEventCallbackControlError = 325
+	// ProcDomainEventCallbackBlockJob is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BLOCK_JOB
+	ProcDomainEventCallbackBlockJob = 326
+	// ProcDomainEventCallbackDiskChange is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DISK_CHANGE
+	ProcDomainEventCallbackDiskChange = 327
+	// ProcDomainEventCallbackTrayChange is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_TRAY_CHANGE
+	ProcDomainEventCallbackTrayChange = 328
+	// ProcDomainEventCallbackPmwakeup is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMWAKEUP
+	ProcDomainEventCallbackPmwakeup = 329
+	// ProcDomainEventCallbackPmsuspend is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND
+	ProcDomainEventCallbackPmsuspend = 330
+	// ProcDomainEventCallbackBalloonChange is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BALLOON_CHANGE
+	ProcDomainEventCallbackBalloonChange = 331
+	// ProcDomainEventCallbackPmsuspendDisk is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND_DISK
+	ProcDomainEventCallbackPmsuspendDisk = 332
+	// ProcDomainEventCallbackDeviceRemoved is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_REMOVED
+	ProcDomainEventCallbackDeviceRemoved = 333
+	// ProcDomainCoreDumpWithFormat is libvirt's REMOTE_PROC_DOMAIN_CORE_DUMP_WITH_FORMAT
+	ProcDomainCoreDumpWithFormat = 334
+	// ProcDomainFsfreeze is libvirt's REMOTE_PROC_DOMAIN_FSFREEZE
+	ProcDomainFsfreeze = 335
+	// ProcDomainFsthaw is libvirt's REMOTE_PROC_DOMAIN_FSTHAW
+	ProcDomainFsthaw = 336
+	// ProcDomainGetTime is libvirt's REMOTE_PROC_DOMAIN_GET_TIME
+	ProcDomainGetTime = 337
+	// ProcDomainSetTime is libvirt's REMOTE_PROC_DOMAIN_SET_TIME
+	ProcDomainSetTime = 338
+	// ProcDomainEventBlockJob2 is libvirt's REMOTE_PROC_DOMAIN_EVENT_BLOCK_JOB_2
+	ProcDomainEventBlockJob2 = 339
+	// ProcNodeGetFreePages is libvirt's REMOTE_PROC_NODE_GET_FREE_PAGES
+	ProcNodeGetFreePages = 340
+	// ProcNetworkGetDhcpLeases is libvirt's REMOTE_PROC_NETWORK_GET_DHCP_LEASES
+	ProcNetworkGetDhcpLeases = 341
+	// ProcConnectGetDomainCapabilities is libvirt's REMOTE_PROC_CONNECT_GET_DOMAIN_CAPABILITIES
+	ProcConnectGetDomainCapabilities = 342
+	// ProcDomainOpenGraphicsFd is libvirt's REMOTE_PROC_DOMAIN_OPEN_GRAPHICS_FD
+	ProcDomainOpenGraphicsFd = 343
+	// ProcConnectGetAllDomainStats is libvirt's REMOTE_PROC_CONNECT_GET_ALL_DOMAIN_STATS
+	ProcConnectGetAllDomainStats = 344
+	// ProcDomainBlockCopy is libvirt's REMOTE_PROC_DOMAIN_BLOCK_COPY
+	ProcDomainBlockCopy = 345
+	// ProcDomainEventCallbackTunable is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_TUNABLE
+	ProcDomainEventCallbackTunable = 346
+	// ProcNodeAllocPages is libvirt's REMOTE_PROC_NODE_ALLOC_PAGES
+	ProcNodeAllocPages = 347
+	// ProcDomainEventCallbackAgentLifecycle is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_AGENT_LIFECYCLE
+	ProcDomainEventCallbackAgentLifecycle = 348
+	// ProcDomainGetFsinfo is libvirt's REMOTE_PROC_DOMAIN_GET_FSINFO
+	ProcDomainGetFsinfo = 349
+	// ProcDomainDefineXMLFlags is libvirt's REMOTE_PROC_DOMAIN_DEFINE_XML_FLAGS
+	ProcDomainDefineXMLFlags = 350
+	// ProcDomainGetIothreadInfo is libvirt's REMOTE_PROC_DOMAIN_GET_IOTHREAD_INFO
+	ProcDomainGetIothreadInfo = 351
+	// ProcDomainPinIothread is libvirt's REMOTE_PROC_DOMAIN_PIN_IOTHREAD
+	ProcDomainPinIothread = 352
+	// ProcDomainInterfaceAddresses is libvirt's REMOTE_PROC_DOMAIN_INTERFACE_ADDRESSES
+	ProcDomainInterfaceAddresses = 353
+	// ProcDomainEventCallbackDeviceAdded is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_ADDED
+	ProcDomainEventCallbackDeviceAdded = 354
+	// ProcDomainAddIothread is libvirt's REMOTE_PROC_DOMAIN_ADD_IOTHREAD
+	ProcDomainAddIothread = 355
+	// ProcDomainDelIothread is libvirt's REMOTE_PROC_DOMAIN_DEL_IOTHREAD
+	ProcDomainDelIothread = 356
+	// ProcDomainSetUserPassword is libvirt's REMOTE_PROC_DOMAIN_SET_USER_PASSWORD
+	ProcDomainSetUserPassword = 357
+	// ProcDomainRename is libvirt's REMOTE_PROC_DOMAIN_RENAME
+	ProcDomainRename = 358
+	// ProcDomainEventCallbackMigrationIteration is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_MIGRATION_ITERATION
+	ProcDomainEventCallbackMigrationIteration = 359
+	// ProcConnectRegisterCloseCallback is libvirt's REMOTE_PROC_CONNECT_REGISTER_CLOSE_CALLBACK
+	ProcConnectRegisterCloseCallback = 360
+	// ProcConnectUnregisterCloseCallback is libvirt's REMOTE_PROC_CONNECT_UNREGISTER_CLOSE_CALLBACK
+	ProcConnectUnregisterCloseCallback = 361
+	// ProcConnectEventConnectionClosed is libvirt's REMOTE_PROC_CONNECT_EVENT_CONNECTION_CLOSED
+	ProcConnectEventConnectionClosed = 362
+	// ProcDomainEventCallbackJobCompleted is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_JOB_COMPLETED
+	ProcDomainEventCallbackJobCompleted = 363
+	// ProcDomainMigrateStartPostCopy is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_START_POST_COPY
+	ProcDomainMigrateStartPostCopy = 364
+	// ProcDomainGetPerfEvents is libvirt's REMOTE_PROC_DOMAIN_GET_PERF_EVENTS
+	ProcDomainGetPerfEvents = 365
+	// ProcDomainSetPerfEvents is libvirt's REMOTE_PROC_DOMAIN_SET_PERF_EVENTS
+	ProcDomainSetPerfEvents = 366
+	// ProcDomainEventCallbackDeviceRemovalFailed is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_REMOVAL_FAILED
+	ProcDomainEventCallbackDeviceRemovalFailed = 367
+	// ProcConnectStoragePoolEventRegisterAny is libvirt's REMOTE_PROC_CONNECT_STORAGE_POOL_EVENT_REGISTER_ANY
+	ProcConnectStoragePoolEventRegisterAny = 368
+	// ProcConnectStoragePoolEventDeregisterAny is libvirt's REMOTE_PROC_CONNECT_STORAGE_POOL_EVENT_DEREGISTER_ANY
+	ProcConnectStoragePoolEventDeregisterAny = 369
+	// ProcStoragePoolEventLifecycle is libvirt's REMOTE_PROC_STORAGE_POOL_EVENT_LIFECYCLE
+	ProcStoragePoolEventLifecycle = 370
+	// ProcDomainGetGuestVcpus is libvirt's REMOTE_PROC_DOMAIN_GET_GUEST_VCPUS
+	ProcDomainGetGuestVcpus = 371
+	// ProcDomainSetGuestVcpus is libvirt's REMOTE_PROC_DOMAIN_SET_GUEST_VCPUS
+	ProcDomainSetGuestVcpus = 372
+	// ProcStoragePoolEventRefresh is libvirt's REMOTE_PROC_STORAGE_POOL_EVENT_REFRESH
+	ProcStoragePoolEventRefresh = 373
+	// ProcConnectNodeDeviceEventRegisterAny is libvirt's REMOTE_PROC_CONNECT_NODE_DEVICE_EVENT_REGISTER_ANY
+	ProcConnectNodeDeviceEventRegisterAny = 374
+	// ProcConnectNodeDeviceEventDeregisterAny is libvirt's REMOTE_PROC_CONNECT_NODE_DEVICE_EVENT_DEREGISTER_ANY
+	ProcConnectNodeDeviceEventDeregisterAny = 375
+	// ProcNodeDeviceEventLifecycle is libvirt's REMOTE_PROC_NODE_DEVICE_EVENT_LIFECYCLE
+	ProcNodeDeviceEventLifecycle = 376
+	// ProcNodeDeviceEventUpdate is libvirt's REMOTE_PROC_NODE_DEVICE_EVENT_UPDATE
+	ProcNodeDeviceEventUpdate = 377
+	// ProcStorageVolGetInfoFlags is libvirt's REMOTE_PROC_STORAGE_VOL_GET_INFO_FLAGS
+	ProcStorageVolGetInfoFlags = 378
+	// ProcDomainEventCallbackMetadataChange is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_METADATA_CHANGE
+	ProcDomainEventCallbackMetadataChange = 379
+	// ProcConnectSecretEventRegisterAny is libvirt's REMOTE_PROC_CONNECT_SECRET_EVENT_REGISTER_ANY
+	ProcConnectSecretEventRegisterAny = 380
+	// ProcConnectSecretEventDeregisterAny is libvirt's REMOTE_PROC_CONNECT_SECRET_EVENT_DEREGISTER_ANY
+	ProcConnectSecretEventDeregisterAny = 381
+	// ProcSecretEventLifecycle is libvirt's REMOTE_PROC_SECRET_EVENT_LIFECYCLE
+	ProcSecretEventLifecycle = 382
+	// ProcSecretEventValueChanged is libvirt's REMOTE_PROC_SECRET_EVENT_VALUE_CHANGED
+	ProcSecretEventValueChanged = 383
+	// ProcDomainSetVcpu is libvirt's REMOTE_PROC_DOMAIN_SET_VCPU
+	ProcDomainSetVcpu = 384
+	// ProcDomainEventBlockThreshold is libvirt's REMOTE_PROC_DOMAIN_EVENT_BLOCK_THRESHOLD
+	ProcDomainEventBlockThreshold = 385
+	// ProcDomainSetBlockThreshold is libvirt's REMOTE_PROC_DOMAIN_SET_BLOCK_THRESHOLD
+	ProcDomainSetBlockThreshold = 386
+	// ProcDomainMigrateGetMaxDowntime is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_GET_MAX_DOWNTIME
+	ProcDomainMigrateGetMaxDowntime = 387
+	// ProcDomainManagedSaveGetXMLDesc is libvirt's REMOTE_PROC_DOMAIN_MANAGED_SAVE_GET_XML_DESC
+	ProcDomainManagedSaveGetXMLDesc = 388
+	// ProcDomainManagedSaveDefineXML is libvirt's REMOTE_PROC_DOMAIN_MANAGED_SAVE_DEFINE_XML
+	ProcDomainManagedSaveDefineXML = 389
+	// ProcDomainSetLifecycleAction is libvirt's REMOTE_PROC_DOMAIN_SET_LIFECYCLE_ACTION
+	ProcDomainSetLifecycleAction = 390
+	// ProcStoragePoolLookupByTargetPath is libvirt's REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_TARGET_PATH
+	ProcStoragePoolLookupByTargetPath = 391
+	// ProcDomainDetachDeviceAlias is libvirt's REMOTE_PROC_DOMAIN_DETACH_DEVICE_ALIAS
+	ProcDomainDetachDeviceAlias = 392
+	// ProcConnectCompareHypervisorCPU is libvirt's REMOTE_PROC_CONNECT_COMPARE_HYPERVISOR_CPU
+	ProcConnectCompareHypervisorCPU = 393
+	// ProcConnectBaselineHypervisorCPU is libvirt's REMOTE_PROC_CONNECT_BASELINE_HYPERVISOR_CPU
+	ProcConnectBaselineHypervisorCPU = 394
+	// ProcNodeGetSevInfo is libvirt's REMOTE_PROC_NODE_GET_SEV_INFO
+	ProcNodeGetSevInfo = 395
+	// ProcDomainGetLaunchSecurityInfo is libvirt's REMOTE_PROC_DOMAIN_GET_LAUNCH_SECURITY_INFO
+	ProcDomainGetLaunchSecurityInfo = 396
+	// ProcNwfilterBindingLookupByPortDev is libvirt's REMOTE_PROC_NWFILTER_BINDING_LOOKUP_BY_PORT_DEV
+	ProcNwfilterBindingLookupByPortDev = 397
+	// ProcNwfilterBindingGetXMLDesc is libvirt's REMOTE_PROC_NWFILTER_BINDING_GET_XML_DESC
+	ProcNwfilterBindingGetXMLDesc = 398
+	// ProcNwfilterBindingCreateXML is libvirt's REMOTE_PROC_NWFILTER_BINDING_CREATE_XML
+	ProcNwfilterBindingCreateXML = 399
+	// ProcNwfilterBindingDelete is libvirt's REMOTE_PROC_NWFILTER_BINDING_DELETE
+	ProcNwfilterBindingDelete = 400
+	// ProcConnectListAllNwfilterBindings is libvirt's REMOTE_PROC_CONNECT_LIST_ALL_NWFILTER_BINDINGS
+	ProcConnectListAllNwfilterBindings = 401
+	// ProcDomainSetIothreadParams is libvirt's REMOTE_PROC_DOMAIN_SET_IOTHREAD_PARAMS
+	ProcDomainSetIothreadParams = 402
+	// ProcConnectGetStoragePoolCapabilities is libvirt's REMOTE_PROC_CONNECT_GET_STORAGE_POOL_CAPABILITIES
+	ProcConnectGetStoragePoolCapabilities = 403
+	// ProcNetworkListAllPorts is libvirt's REMOTE_PROC_NETWORK_LIST_ALL_PORTS
+	ProcNetworkListAllPorts = 404
+	// ProcNetworkPortLookupByUUID is libvirt's REMOTE_PROC_NETWORK_PORT_LOOKUP_BY_UUID
+	ProcNetworkPortLookupByUUID = 405
+	// ProcNetworkPortCreateXML is libvirt's REMOTE_PROC_NETWORK_PORT_CREATE_XML
+	ProcNetworkPortCreateXML = 406
+	// ProcNetworkPortGetParameters is libvirt's REMOTE_PROC_NETWORK_PORT_GET_PARAMETERS
+	ProcNetworkPortGetParameters = 407
+	// ProcNetworkPortSetParameters is libvirt's REMOTE_PROC_NETWORK_PORT_SET_PARAMETERS
+	ProcNetworkPortSetParameters = 408
+	// ProcNetworkPortGetXMLDesc is libvirt's REMOTE_PROC_NETWORK_PORT_GET_XML_DESC
+	ProcNetworkPortGetXMLDesc = 409
+	// ProcNetworkPortDelete is libvirt's REMOTE_PROC_NETWORK_PORT_DELETE
+	ProcNetworkPortDelete = 410
+	// ProcDomainCheckpointCreateXML is libvirt's REMOTE_PROC_DOMAIN_CHECKPOINT_CREATE_XML
+	ProcDomainCheckpointCreateXML = 411
+	// ProcDomainCheckpointGetXMLDesc is libvirt's REMOTE_PROC_DOMAIN_CHECKPOINT_GET_XML_DESC
+	ProcDomainCheckpointGetXMLDesc = 412
+	// ProcDomainListAllCheckpoints is libvirt's REMOTE_PROC_DOMAIN_LIST_ALL_CHECKPOINTS
+	ProcDomainListAllCheckpoints = 413
+	// ProcDomainCheckpointListAllChildren is libvirt's REMOTE_PROC_DOMAIN_CHECKPOINT_LIST_ALL_CHILDREN
+	ProcDomainCheckpointListAllChildren = 414
+	// ProcDomainCheckpointLookupByName is libvirt's REMOTE_PROC_DOMAIN_CHECKPOINT_LOOKUP_BY_NAME
+	ProcDomainCheckpointLookupByName = 415
+	// ProcDomainCheckpointGetParent is libvirt's REMOTE_PROC_DOMAIN_CHECKPOINT_GET_PARENT
+	ProcDomainCheckpointGetParent = 416
+	// ProcDomainCheckpointDelete is libvirt's REMOTE_PROC_DOMAIN_CHECKPOINT_DELETE
+	ProcDomainCheckpointDelete = 417
+	// ProcDomainGetGuestInfo is libvirt's REMOTE_PROC_DOMAIN_GET_GUEST_INFO
+	ProcDomainGetGuestInfo = 418
+	// ProcConnectSetIdentity is libvirt's REMOTE_PROC_CONNECT_SET_IDENTITY
+	ProcConnectSetIdentity = 419
+	// ProcDomainAgentSetResponseTimeout is libvirt's REMOTE_PROC_DOMAIN_AGENT_SET_RESPONSE_TIMEOUT
+	ProcDomainAgentSetResponseTimeout = 420
+	// ProcDomainBackupBegin is libvirt's REMOTE_PROC_DOMAIN_BACKUP_BEGIN
+	ProcDomainBackupBegin = 421
+	// ProcDomainBackupGetXMLDesc is libvirt's REMOTE_PROC_DOMAIN_BACKUP_GET_XML_DESC
+	ProcDomainBackupGetXMLDesc = 422
+	// ProcDomainEventMemoryFailure is libvirt's REMOTE_PROC_DOMAIN_EVENT_MEMORY_FAILURE
+	ProcDomainEventMemoryFailure = 423
+	// ProcDomainAuthorizedSshKeysGet is libvirt's REMOTE_PROC_DOMAIN_AUTHORIZED_SSH_KEYS_GET
+	ProcDomainAuthorizedSshKeysGet = 424
+	// ProcDomainAuthorizedSshKeysSet is libvirt's REMOTE_PROC_DOMAIN_AUTHORIZED_SSH_KEYS_SET
+	ProcDomainAuthorizedSshKeysSet = 425
+
+
+	// From consts:
+	// StringMax is libvirt's REMOTE_STRING_MAX
+	StringMax = 4194304
+	// ConnectIdentityParamsMax is libvirt's REMOTE_CONNECT_IDENTITY_PARAMS_MAX
+	ConnectIdentityParamsMax = 20
+	// DomainListMax is libvirt's REMOTE_DOMAIN_LIST_MAX
+	DomainListMax = 16384
+	// CpumapMax is libvirt's REMOTE_CPUMAP_MAX
+	CpumapMax = 2048
+	// VcpuinfoMax is libvirt's REMOTE_VCPUINFO_MAX
+	VcpuinfoMax = 16384
+	// CpumapsMax is libvirt's REMOTE_CPUMAPS_MAX
+	CpumapsMax = 8388608
+	// IothreadInfoMax is libvirt's REMOTE_IOTHREAD_INFO_MAX
+	IothreadInfoMax = 16384
+	// MigrateCookieMax is libvirt's REMOTE_MIGRATE_COOKIE_MAX
+	MigrateCookieMax = 4194304
+	// NetworkListMax is libvirt's REMOTE_NETWORK_LIST_MAX
+	NetworkListMax = 16384
+	// NetworkPortListMax is libvirt's REMOTE_NETWORK_PORT_LIST_MAX
+	NetworkPortListMax = 16384
+	// InterfaceListMax is libvirt's REMOTE_INTERFACE_LIST_MAX
+	InterfaceListMax = 16384
+	// StoragePoolListMax is libvirt's REMOTE_STORAGE_POOL_LIST_MAX
+	StoragePoolListMax = 16384
+	// StorageVolListMax is libvirt's REMOTE_STORAGE_VOL_LIST_MAX
+	StorageVolListMax = 16384
+	// NodeDeviceListMax is libvirt's REMOTE_NODE_DEVICE_LIST_MAX
+	NodeDeviceListMax = 65536
+	// NodeDeviceCapsListMax is libvirt's REMOTE_NODE_DEVICE_CAPS_LIST_MAX
+	NodeDeviceCapsListMax = 65536
+	// NwfilterListMax is libvirt's REMOTE_NWFILTER_LIST_MAX
+	NwfilterListMax = 16384
+	// NwfilterBindingListMax is libvirt's REMOTE_NWFILTER_BINDING_LIST_MAX
+	NwfilterBindingListMax = 16384
+	// DomainSchedulerParametersMax is libvirt's REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX
+	DomainSchedulerParametersMax = 16
+	// DomainBlkioParametersMax is libvirt's REMOTE_DOMAIN_BLKIO_PARAMETERS_MAX
+	DomainBlkioParametersMax = 16
+	// DomainMemoryParametersMax is libvirt's REMOTE_DOMAIN_MEMORY_PARAMETERS_MAX
+	DomainMemoryParametersMax = 16
+	// DomainBlockIOTuneParametersMax is libvirt's REMOTE_DOMAIN_BLOCK_IO_TUNE_PARAMETERS_MAX
+	DomainBlockIOTuneParametersMax = 32
+	// DomainNumaParametersMax is libvirt's REMOTE_DOMAIN_NUMA_PARAMETERS_MAX
+	DomainNumaParametersMax = 16
+	// DomainPerfEventsMax is libvirt's REMOTE_DOMAIN_PERF_EVENTS_MAX
+	DomainPerfEventsMax = 64
+	// DomainBlockCopyParametersMax is libvirt's REMOTE_DOMAIN_BLOCK_COPY_PARAMETERS_MAX
+	DomainBlockCopyParametersMax = 16
+	// NodeCPUStatsMax is libvirt's REMOTE_NODE_CPU_STATS_MAX
+	NodeCPUStatsMax = 16
+	// NodeMemoryStatsMax is libvirt's REMOTE_NODE_MEMORY_STATS_MAX
+	NodeMemoryStatsMax = 16
+	// DomainBlockStatsParametersMax is libvirt's REMOTE_DOMAIN_BLOCK_STATS_PARAMETERS_MAX
+	DomainBlockStatsParametersMax = 16
+	// NodeMaxCells is libvirt's REMOTE_NODE_MAX_CELLS
+	NodeMaxCells = 1024
+	// AuthSaslDataMax is libvirt's REMOTE_AUTH_SASL_DATA_MAX
+	AuthSaslDataMax = 65536
+	// AuthTypeListMax is libvirt's REMOTE_AUTH_TYPE_LIST_MAX
+	AuthTypeListMax = 20
+	// DomainMemoryStatsMax is libvirt's REMOTE_DOMAIN_MEMORY_STATS_MAX
+	DomainMemoryStatsMax = 1024
+	// DomainCheckpointListMax is libvirt's REMOTE_DOMAIN_CHECKPOINT_LIST_MAX
+	DomainCheckpointListMax = 16384
+	// DomainSnapshotListMax is libvirt's REMOTE_DOMAIN_SNAPSHOT_LIST_MAX
+	DomainSnapshotListMax = 16384
+	// DomainBlockPeekBufferMax is libvirt's REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX
+	DomainBlockPeekBufferMax = 4194304
+	// DomainMemoryPeekBufferMax is libvirt's REMOTE_DOMAIN_MEMORY_PEEK_BUFFER_MAX
+	DomainMemoryPeekBufferMax = 4194304
+	// SecurityLabelListMax is libvirt's REMOTE_SECURITY_LABEL_LIST_MAX
+	SecurityLabelListMax = 64
+	// SecretValueMax is libvirt's REMOTE_SECRET_VALUE_MAX
+	SecretValueMax = 65536
+	// SecretListMax is libvirt's REMOTE_SECRET_LIST_MAX
+	SecretListMax = 16384
+	// CPUBaselineMax is libvirt's REMOTE_CPU_BASELINE_MAX
+	CPUBaselineMax = 256
+	// DomainSendKeyMax is libvirt's REMOTE_DOMAIN_SEND_KEY_MAX
+	DomainSendKeyMax = 16
+	// DomainInterfaceParametersMax is libvirt's REMOTE_DOMAIN_INTERFACE_PARAMETERS_MAX
+	DomainInterfaceParametersMax = 16
+	// DomainGetCPUStatsNcpusMax is libvirt's REMOTE_DOMAIN_GET_CPU_STATS_NCPUS_MAX
+	DomainGetCPUStatsNcpusMax = 128
+	// DomainGetCPUStatsMax is libvirt's REMOTE_DOMAIN_GET_CPU_STATS_MAX
+	DomainGetCPUStatsMax = 2048
+	// DomainDiskErrorsMax is libvirt's REMOTE_DOMAIN_DISK_ERRORS_MAX
+	DomainDiskErrorsMax = 256
+	// NodeMemoryParametersMax is libvirt's REMOTE_NODE_MEMORY_PARAMETERS_MAX
+	NodeMemoryParametersMax = 64
+	// DomainMigrateParamListMax is libvirt's REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX
+	DomainMigrateParamListMax = 64
+	// DomainJobStatsMax is libvirt's REMOTE_DOMAIN_JOB_STATS_MAX
+	DomainJobStatsMax = 64
+	// ConnectCPUModelsMax is libvirt's REMOTE_CONNECT_CPU_MODELS_MAX
+	ConnectCPUModelsMax = 8192
+	// DomainFsfreezeMountpointsMax is libvirt's REMOTE_DOMAIN_FSFREEZE_MOUNTPOINTS_MAX
+	DomainFsfreezeMountpointsMax = 256
+	// NetworkDhcpLeasesMax is libvirt's REMOTE_NETWORK_DHCP_LEASES_MAX
+	NetworkDhcpLeasesMax = 65536
+	// ConnectGetAllDomainStatsMax is libvirt's REMOTE_CONNECT_GET_ALL_DOMAIN_STATS_MAX
+	ConnectGetAllDomainStatsMax = 262144
+	// DomainEventTunableMax is libvirt's REMOTE_DOMAIN_EVENT_TUNABLE_MAX
+	DomainEventTunableMax = 2048
+	// DomainFsinfoMax is libvirt's REMOTE_DOMAIN_FSINFO_MAX
+	DomainFsinfoMax = 256
+	// DomainFsinfoDisksMax is libvirt's REMOTE_DOMAIN_FSINFO_DISKS_MAX
+	DomainFsinfoDisksMax = 256
+	// DomainInterfaceMax is libvirt's REMOTE_DOMAIN_INTERFACE_MAX
+	DomainInterfaceMax = 2048
+	// DomainIPAddrMax is libvirt's REMOTE_DOMAIN_IP_ADDR_MAX
+	DomainIPAddrMax = 2048
+	// DomainGuestVcpuParamsMax is libvirt's REMOTE_DOMAIN_GUEST_VCPU_PARAMS_MAX
+	DomainGuestVcpuParamsMax = 64
+	// DomainIothreadParamsMax is libvirt's REMOTE_DOMAIN_IOTHREAD_PARAMS_MAX
+	DomainIothreadParamsMax = 64
+	// NodeSevInfoMax is libvirt's REMOTE_NODE_SEV_INFO_MAX
+	NodeSevInfoMax = 64
+	// DomainLaunchSecurityInfoParamsMax is libvirt's REMOTE_DOMAIN_LAUNCH_SECURITY_INFO_PARAMS_MAX
+	DomainLaunchSecurityInfoParamsMax = 64
+	// DomainGuestInfoParamsMax is libvirt's REMOTE_DOMAIN_GUEST_INFO_PARAMS_MAX
+	DomainGuestInfoParamsMax = 2048
+	// NetworkPortParametersMax is libvirt's REMOTE_NETWORK_PORT_PARAMETERS_MAX
+	NetworkPortParametersMax = 16
+	// DomainAuthorizedSshKeysMax is libvirt's REMOTE_DOMAIN_AUTHORIZED_SSH_KEYS_MAX
+	DomainAuthorizedSshKeysMax = 2048
+	// DomainEventGraphicsIdentityMax is libvirt's REMOTE_DOMAIN_EVENT_GRAPHICS_IDENTITY_MAX
+	DomainEventGraphicsIdentityMax = 20
+	// Program is libvirt's REMOTE_PROGRAM
+	Program = 0x20008086
+	// ProtocolVersion is libvirt's REMOTE_PROTOCOL_VERSION
+	ProtocolVersion = 1
+)
diff --git a/vendor/github.com/digitalocean/go-libvirt/internal/event/event.go b/vendor/github.com/digitalocean/go-libvirt/internal/event/event.go
new file mode 100644
index 000000000..67a1885b9
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/internal/event/event.go
@@ -0,0 +1,20 @@
+// Copyright 2020 The go-libvirt Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package event
+
+// Event represents an internal Event.
+type Event interface {
+	GetCallbackID() int32
+}
diff --git a/vendor/github.com/digitalocean/go-libvirt/internal/event/stream.go b/vendor/github.com/digitalocean/go-libvirt/internal/event/stream.go
new file mode 100644
index 000000000..b14e41b64
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/internal/event/stream.go
@@ -0,0 +1,145 @@
+// Copyright 2020 The go-libvirt Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package event
+
+import "context"
+
+// Stream is an unbounded buffered event channel. The implementation
+// consists of a pair of unbuffered channels and a goroutine to manage them.
+// Client behavior will not cause incoming events to block.
+type Stream struct {
+	// Program specifies the source of the events - libvirt or QEMU.
+	Program uint32
+
+	// CallbackID is returned by the event registration call.
+	CallbackID int32
+
+	// manage unbounded channel behavior.
+	queue   []Event
+	in, out chan Event
+
+	// terminates processing
+	shutdown context.CancelFunc
+}
+
+// Recv returns the next available event from the Stream's queue.
+func (s *Stream) Recv() chan Event {
+	return s.out
+}
+
+// Push appends a new event to the queue.
+func (s *Stream) Push(e Event) {
+	s.in <- e
+}
+
+// Shutdown gracefully terminates Stream processing, releasing all
+// internal resources. Events which have not yet been received by the client
+// will be dropped. Subsequent calls to Shutdown() are idempotent.
+func (s *Stream) Shutdown() {
+	if s.shutdown != nil {
+		s.shutdown()
+	}
+}
+
+// start starts the event processing loop, which will continue to run until
+// terminated by the returned context.CancelFunc. Starting a previously started
+// Stream is an idempotent operation.
+func (s *Stream) start() context.CancelFunc {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	go s.process(ctx)
+
+	return cancel
+}
+
+// process manages an Stream's lifecycle until canceled by the provided
+// context.  Incoming events are appended to a queue which is then relayed to
+// the a listening client. New events pushed onto the queue will not block due
+// to client behavior.
+func (s *Stream) process(ctx context.Context) {
+	defer func() {
+		close(s.in)
+		close(s.out)
+	}()
+
+	for {
+		// informs send() to stop trying
+		nctx, next := context.WithCancel(ctx)
+		defer next()
+
+		select {
+		// new event received, append to queue
+		case e := <-s.in:
+			s.queue = append(s.queue, e)
+
+		// client recieved an event, pop from queue
+		case <-s.send(nctx):
+			if len(s.queue) > 1 {
+				s.queue = s.queue[1:]
+			} else {
+				s.queue = []Event{}
+			}
+
+		// shutdown requested
+		case <-ctx.Done():
+			return
+
+		}
+
+		next()
+	}
+}
+
+// send returns a channel which blocks until either the first item on the queue
+// (if existing) is sent to the client, or the provided context is canceled.
+// The stream's queue is never modified.
+func (s *Stream) send(ctx context.Context) <-chan struct{} {
+	ch := make(chan struct{})
+
+	go func() {
+		defer close(ch)
+
+		// do nothing and block if the queue is empty
+		if len(s.queue) == 0 {
+			<-ctx.Done()
+			return
+		}
+
+		// otherwise, attempt to send the event
+		select {
+		case s.out <- s.queue[0]:
+		case <-ctx.Done():
+		}
+	}()
+
+	return ch
+}
+
+// NewStream configures a new Event Stream. Incoming events are appended to a
+// queue, which is then relayed to the listening client. Client behavior will
+// not cause incoming events to block. It is the responsibility of the caller
+// to terminate the Stream via Shutdown() when no longer in use.
+func NewStream(program uint32, cbID int32) *Stream {
+	ic := &Stream{
+		Program:    program,
+		CallbackID: cbID,
+		in:         make(chan Event),
+		out:        make(chan Event),
+	}
+
+	ic.shutdown = ic.start()
+
+	return ic
+}
diff --git a/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/LICENSE b/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/LICENSE
new file mode 100644
index 000000000..0cc3543ce
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/LICENSE
@@ -0,0 +1,13 @@
+Copyright (c) 2012-2014 Dave Collins <dave@davec.name>
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
\ No newline at end of file
diff --git a/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/decode.go b/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/decode.go
new file mode 100644
index 000000000..7f33f7d32
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/decode.go
@@ -0,0 +1,896 @@
+/*
+ * Copyright (c) 2012-2014 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package xdr
+
+import (
+	"fmt"
+	"io"
+	"math"
+	"reflect"
+	"time"
+)
+
+var (
+	errMaxSlice = "data exceeds max slice limit"
+	errIODecode = "%s while decoding %d bytes"
+)
+
+/*
+Unmarshal parses XDR-encoded data into the value pointed to by v reading from
+reader r and returning the total number of bytes read.  An addressable pointer
+must be provided since Unmarshal needs to both store the result of the decode as
+well as obtain target type information.  Unmarhsal traverses v recursively and
+automatically indirects pointers through arbitrary depth, allocating them as
+necessary, to decode the data into the underlying value pointed to.
+
+Unmarshal uses reflection to determine the type of the concrete value contained
+by v and performs a mapping of underlying XDR types to Go types as follows:
+
+	Go Type <- XDR Type
+	--------------------
+	int8, int16, int32, int <- XDR Integer
+	uint8, uint16, uint32, uint <- XDR Unsigned Integer
+	int64 <- XDR Hyper Integer
+	uint64 <- XDR Unsigned Hyper Integer
+	bool <- XDR Boolean
+	float32 <- XDR Floating-Point
+	float64 <- XDR Double-Precision Floating-Point
+	string <- XDR String
+	byte <- XDR Integer
+	[]byte <- XDR Variable-Length Opaque Data
+	[#]byte <- XDR Fixed-Length Opaque Data
+	[]<type> <- XDR Variable-Length Array
+	[#]<type> <- XDR Fixed-Length Array
+	struct <- XDR Structure
+	map <- XDR Variable-Length Array of two-element XDR Structures
+	time.Time <- XDR String encoded with RFC3339 nanosecond precision
+
+Notes and Limitations:
+
+	* Automatic unmarshalling of variable and fixed-length arrays of uint8s
+	  requires a special struct tag `xdropaque:"false"` since byte slices
+	  and byte arrays are assumed to be opaque data and byte is a Go alias
+	  for uint8 thus indistinguishable under reflection
+	* Cyclic data structures are not supported and will result in infinite
+	  loops
+
+If any issues are encountered during the unmarshalling process, an
+UnmarshalError is returned with a human readable description as well as
+an ErrorCode value for further inspection from sophisticated callers.  Some
+potential issues are unsupported Go types, attempting to decode a value which is
+too large to fit into a specified Go type, and exceeding max slice limitations.
+*/
+func Unmarshal(r io.Reader, v interface{}) (int, error) {
+	d := Decoder{r: r}
+	return d.Decode(v)
+}
+
+// UnmarshalLimited is identical to Unmarshal but it sets maxReadSize in order
+// to cap reads.
+func UnmarshalLimited(r io.Reader, v interface{}, maxSize uint) (int, error) {
+	d := Decoder{r: r, maxReadSize: maxSize}
+	return d.Decode(v)
+}
+
+// TypeDecoder lets a caller provide a custom decode routine for a custom type.
+type TypeDecoder interface {
+	Decode(*Decoder, reflect.Value) (int, error)
+}
+
+// A Decoder wraps an io.Reader that is expected to provide an XDR-encoded byte
+// stream and provides several exposed methods to manually decode various XDR
+// primitives without relying on reflection.  The NewDecoder function can be
+// used to get a new Decoder directly.
+//
+// Typically, Unmarshal should be used instead of manual decoding.  A Decoder
+// is exposed so it is possible to perform manual decoding should it be
+// necessary in complex scenarios where automatic reflection-based decoding
+// won't work.
+type Decoder struct {
+	r io.Reader
+
+	// maxReadSize is the default maximum bytes an element can contain.  0
+	// is unlimited and provides backwards compatability.  Setting it to a
+	// non-zero value caps reads.
+	maxReadSize uint
+
+	// customTypes is a map allowing the caller to provide decoder routines for
+	// custom types known only to itself.
+	customTypes map[string]TypeDecoder
+}
+
+// DecodeInt treats the next 4 bytes as an XDR encoded integer and returns the
+// result as an int32 along with the number of bytes actually read.
+//
+// An UnmarshalError is returned if there are insufficient bytes remaining.
+//
+// Reference:
+// 	RFC Section 4.1 - Integer
+// 	32-bit big-endian signed integer in range [-2147483648, 2147483647]
+func (d *Decoder) DecodeInt() (int32, int, error) {
+	var buf [4]byte
+	n, err := io.ReadFull(d.r, buf[:])
+	if err != nil {
+		msg := fmt.Sprintf(errIODecode, err.Error(), 4)
+		err := unmarshalError("DecodeInt", ErrIO, msg, buf[:n], err)
+		return 0, n, err
+	}
+
+	rv := int32(buf[3]) | int32(buf[2])<<8 |
+		int32(buf[1])<<16 | int32(buf[0])<<24
+	return rv, n, nil
+}
+
+// DecodeUint treats the next 4 bytes as an XDR encoded unsigned integer and
+// returns the result as a uint32 along with the number of bytes actually read.
+//
+// An UnmarshalError is returned if there are insufficient bytes remaining.
+//
+// Reference:
+// 	RFC Section 4.2 - Unsigned Integer
+// 	32-bit big-endian unsigned integer in range [0, 4294967295]
+func (d *Decoder) DecodeUint() (uint32, int, error) {
+	var buf [4]byte
+	n, err := io.ReadFull(d.r, buf[:])
+	if err != nil {
+		msg := fmt.Sprintf(errIODecode, err.Error(), 4)
+		err := unmarshalError("DecodeUint", ErrIO, msg, buf[:n], err)
+		return 0, n, err
+	}
+
+	rv := uint32(buf[3]) | uint32(buf[2])<<8 |
+		uint32(buf[1])<<16 | uint32(buf[0])<<24
+	return rv, n, nil
+}
+
+// DecodeEnum treats the next 4 bytes as an XDR encoded enumeration value and
+// returns the result as an int32 after verifying that the value is in the
+// provided map of valid values.   It also returns the number of bytes actually
+// read.
+//
+// An UnmarshalError is returned if there are insufficient bytes remaining or
+// the parsed enumeration value is not one of the provided valid values.
+//
+// Reference:
+// 	RFC Section 4.3 - Enumeration
+// 	Represented as an XDR encoded signed integer
+func (d *Decoder) DecodeEnum(validEnums map[int32]bool) (int32, int, error) {
+	val, n, err := d.DecodeInt()
+	if err != nil {
+		return 0, n, err
+	}
+
+	if !validEnums[val] {
+		err := unmarshalError("DecodeEnum", ErrBadEnumValue,
+			"invalid enum", val, nil)
+		return 0, n, err
+	}
+	return val, n, nil
+}
+
+// DecodeBool treats the next 4 bytes as an XDR encoded boolean value and
+// returns the result as a bool along with the number of bytes actually read.
+//
+// An UnmarshalError is returned if there are insufficient bytes remaining or
+// the parsed value is not a 0 or 1.
+//
+// Reference:
+// 	RFC Section 4.4 - Boolean
+// 	Represented as an XDR encoded enumeration where 0 is false and 1 is true
+func (d *Decoder) DecodeBool() (bool, int, error) {
+	val, n, err := d.DecodeInt()
+	if err != nil {
+		return false, n, err
+	}
+	switch val {
+	case 0:
+		return false, n, nil
+	case 1:
+		return true, n, nil
+	}
+
+	err = unmarshalError("DecodeBool", ErrBadEnumValue, "bool not 0 or 1",
+		val, nil)
+	return false, n, err
+}
+
+// DecodeHyper treats the next 8 bytes as an XDR encoded hyper value and
+// returns the result as an int64  along with the number of bytes actually read.
+//
+// An UnmarshalError is returned if there are insufficient bytes remaining.
+//
+// Reference:
+// 	RFC Section 4.5 - Hyper Integer
+// 	64-bit big-endian signed integer in range [-9223372036854775808, 9223372036854775807]
+func (d *Decoder) DecodeHyper() (int64, int, error) {
+	var buf [8]byte
+	n, err := io.ReadFull(d.r, buf[:])
+	if err != nil {
+		msg := fmt.Sprintf(errIODecode, err.Error(), 8)
+		err := unmarshalError("DecodeHyper", ErrIO, msg, buf[:n], err)
+		return 0, n, err
+	}
+
+	rv := int64(buf[7]) | int64(buf[6])<<8 |
+		int64(buf[5])<<16 | int64(buf[4])<<24 |
+		int64(buf[3])<<32 | int64(buf[2])<<40 |
+		int64(buf[1])<<48 | int64(buf[0])<<56
+	return rv, n, err
+}
+
+// DecodeUhyper treats the next 8  bytes as an XDR encoded unsigned hyper value
+// and returns the result as a uint64  along with the number of bytes actually
+// read.
+//
+// An UnmarshalError is returned if there are insufficient bytes remaining.
+//
+// Reference:
+// 	RFC Section 4.5 - Unsigned Hyper Integer
+// 	64-bit big-endian unsigned integer in range [0, 18446744073709551615]
+func (d *Decoder) DecodeUhyper() (uint64, int, error) {
+	var buf [8]byte
+	n, err := io.ReadFull(d.r, buf[:])
+	if err != nil {
+		msg := fmt.Sprintf(errIODecode, err.Error(), 8)
+		err := unmarshalError("DecodeUhyper", ErrIO, msg, buf[:n], err)
+		return 0, n, err
+	}
+
+	rv := uint64(buf[7]) | uint64(buf[6])<<8 |
+		uint64(buf[5])<<16 | uint64(buf[4])<<24 |
+		uint64(buf[3])<<32 | uint64(buf[2])<<40 |
+		uint64(buf[1])<<48 | uint64(buf[0])<<56
+	return rv, n, nil
+}
+
+// DecodeFloat treats the next 4 bytes as an XDR encoded floating point and
+// returns the result as a float32 along with the number of bytes actually read.
+//
+// An UnmarshalError is returned if there are insufficient bytes remaining.
+//
+// Reference:
+// 	RFC Section 4.6 - Floating Point
+// 	32-bit single-precision IEEE 754 floating point
+func (d *Decoder) DecodeFloat() (float32, int, error) {
+	var buf [4]byte
+	n, err := io.ReadFull(d.r, buf[:])
+	if err != nil {
+		msg := fmt.Sprintf(errIODecode, err.Error(), 4)
+		err := unmarshalError("DecodeFloat", ErrIO, msg, buf[:n], err)
+		return 0, n, err
+	}
+
+	val := uint32(buf[3]) | uint32(buf[2])<<8 |
+		uint32(buf[1])<<16 | uint32(buf[0])<<24
+	return math.Float32frombits(val), n, nil
+}
+
+// DecodeDouble treats the next 8 bytes as an XDR encoded double-precision
+// floating point and returns the result as a float64 along with the number of
+// bytes actually read.
+//
+// An UnmarshalError is returned if there are insufficient bytes remaining.
+//
+// Reference:
+// 	RFC Section 4.7 -  Double-Precision Floating Point
+// 	64-bit double-precision IEEE 754 floating point
+func (d *Decoder) DecodeDouble() (float64, int, error) {
+	var buf [8]byte
+	n, err := io.ReadFull(d.r, buf[:])
+	if err != nil {
+		msg := fmt.Sprintf(errIODecode, err.Error(), 8)
+		err := unmarshalError("DecodeDouble", ErrIO, msg, buf[:n], err)
+		return 0, n, err
+	}
+
+	val := uint64(buf[7]) | uint64(buf[6])<<8 |
+		uint64(buf[5])<<16 | uint64(buf[4])<<24 |
+		uint64(buf[3])<<32 | uint64(buf[2])<<40 |
+		uint64(buf[1])<<48 | uint64(buf[0])<<56
+	return math.Float64frombits(val), n, nil
+}
+
+// RFC Section 4.8 -  Quadruple-Precision Floating Point
+// 128-bit quadruple-precision floating point
+// Not Implemented
+
+// DecodeFixedOpaque treats the next 'size' bytes as XDR encoded opaque data and
+// returns the result as a byte slice along with the number of bytes actually
+// read.
+//
+// An UnmarshalError is returned if there are insufficient bytes remaining to
+// satisfy the passed size, including the necessary padding to make it a
+// multiple of 4.
+//
+// Reference:
+// 	RFC Section 4.9 - Fixed-Length Opaque Data
+// 	Fixed-length uninterpreted data zero-padded to a multiple of four
+func (d *Decoder) DecodeFixedOpaque(size int32) ([]byte, int, error) {
+	// Nothing to do if size is 0.
+	if size == 0 {
+		return nil, 0, nil
+	}
+
+	pad := (4 - (size % 4)) % 4
+	paddedSize := size + pad
+	if uint(paddedSize) > uint(math.MaxInt32) {
+		err := unmarshalError("DecodeFixedOpaque", ErrOverflow,
+			errMaxSlice, paddedSize, nil)
+		return nil, 0, err
+	}
+
+	buf := make([]byte, paddedSize)
+	n, err := io.ReadFull(d.r, buf)
+	if err != nil {
+		msg := fmt.Sprintf(errIODecode, err.Error(), paddedSize)
+		err := unmarshalError("DecodeFixedOpaque", ErrIO, msg, buf[:n],
+			err)
+		return nil, n, err
+	}
+	return buf[0:size], n, nil
+}
+
+// DecodeOpaque treats the next bytes as variable length XDR encoded opaque
+// data and returns the result as a byte slice along with the number of bytes
+// actually read.
+//
+// An UnmarshalError is returned if there are insufficient bytes remaining or
+// the opaque data is larger than the max length of a Go slice.
+//
+// Reference:
+// 	RFC Section 4.10 - Variable-Length Opaque Data
+// 	Unsigned integer length followed by fixed opaque data of that length
+func (d *Decoder) DecodeOpaque() ([]byte, int, error) {
+	dataLen, n, err := d.DecodeUint()
+	if err != nil {
+		return nil, n, err
+	}
+	if uint(dataLen) > uint(math.MaxInt32) ||
+		(d.maxReadSize != 0 && uint(dataLen) > d.maxReadSize) {
+		err := unmarshalError("DecodeOpaque", ErrOverflow, errMaxSlice,
+			dataLen, nil)
+		return nil, n, err
+	}
+
+	rv, n2, err := d.DecodeFixedOpaque(int32(dataLen))
+	n += n2
+	if err != nil {
+		return nil, n, err
+	}
+	return rv, n, nil
+}
+
+// DecodeString treats the next bytes as a variable length XDR encoded string
+// and returns the result as a string along with the number of bytes actually
+// read.  Character encoding is assumed to be UTF-8 and therefore ASCII
+// compatible.  If the underlying character encoding is not compatibile with
+// this assumption, the data can instead be read as variable-length opaque data
+// (DecodeOpaque) and manually converted as needed.
+//
+// An UnmarshalError is returned if there are insufficient bytes remaining or
+// the string data is larger than the max length of a Go slice.
+//
+// Reference:
+// 	RFC Section 4.11 - String
+// 	Unsigned integer length followed by bytes zero-padded to a multiple of
+// 	four
+func (d *Decoder) DecodeString() (string, int, error) {
+	dataLen, n, err := d.DecodeUint()
+	if err != nil {
+		return "", n, err
+	}
+	if uint(dataLen) > uint(math.MaxInt32) ||
+		(d.maxReadSize != 0 && uint(dataLen) > d.maxReadSize) {
+		err = unmarshalError("DecodeString", ErrOverflow, errMaxSlice,
+			dataLen, nil)
+		return "", n, err
+	}
+
+	opaque, n2, err := d.DecodeFixedOpaque(int32(dataLen))
+	n += n2
+	if err != nil {
+		return "", n, err
+	}
+	return string(opaque), n, nil
+}
+
+// decodeFixedArray treats the next bytes as a series of XDR encoded elements
+// of the same type as the array represented by the reflection value and decodes
+// each element into the passed array.  The ignoreOpaque flag controls whether
+// or not uint8 (byte) elements should be decoded individually or as a fixed
+// sequence of opaque data.  It returns the  the number of bytes actually read.
+//
+// An UnmarshalError is returned if any issues are encountered while decoding
+// the array elements.
+//
+// Reference:
+// 	RFC Section 4.12 - Fixed-Length Array
+// 	Individually XDR encoded array elements
+func (d *Decoder) decodeFixedArray(v reflect.Value, ignoreOpaque bool) (int, error) {
+	// Treat [#]byte (byte is alias for uint8) as opaque data unless
+	// ignored.
+	if !ignoreOpaque && v.Type().Elem().Kind() == reflect.Uint8 {
+		data, n, err := d.DecodeFixedOpaque(int32(v.Len()))
+		if err != nil {
+			return n, err
+		}
+		reflect.Copy(v, reflect.ValueOf(data))
+		return n, nil
+	}
+
+	// Decode each array element.
+	var n int
+	for i := 0; i < v.Len(); i++ {
+		n2, err := d.decode(v.Index(i))
+		n += n2
+		if err != nil {
+			return n, err
+		}
+	}
+	return n, nil
+}
+
+// decodeArray treats the next bytes as a variable length series of XDR encoded
+// elements of the same type as the array represented by the reflection value.
+// The number of elements is obtained by first decoding the unsigned integer
+// element count.  Then each element is decoded into the passed array. The
+// ignoreOpaque flag controls whether or not uint8 (byte) elements should be
+// decoded individually or as a variable sequence of opaque data.  It returns
+// the number of bytes actually read.
+//
+// An UnmarshalError is returned if any issues are encountered while decoding
+// the array elements.
+//
+// Reference:
+// 	RFC Section 4.13 - Variable-Length Array
+// 	Unsigned integer length followed by individually XDR encoded array
+// 	elements
+func (d *Decoder) decodeArray(v reflect.Value, ignoreOpaque bool) (int, error) {
+	dataLen, n, err := d.DecodeUint()
+	if err != nil {
+		return n, err
+	}
+	if uint(dataLen) > uint(math.MaxInt32) ||
+		(d.maxReadSize != 0 && uint(dataLen) > d.maxReadSize) {
+		err := unmarshalError("decodeArray", ErrOverflow, errMaxSlice,
+			dataLen, nil)
+		return n, err
+	}
+
+	// Allocate storage for the slice elements (the underlying array) if
+	// existing slice does not have enough capacity.
+	sliceLen := int(dataLen)
+	if v.Cap() < sliceLen {
+		v.Set(reflect.MakeSlice(v.Type(), sliceLen, sliceLen))
+	}
+	if v.Len() < sliceLen {
+		v.SetLen(sliceLen)
+	}
+
+	// Treat []byte (byte is alias for uint8) as opaque data unless ignored.
+	if !ignoreOpaque && v.Type().Elem().Kind() == reflect.Uint8 {
+		data, n2, err := d.DecodeFixedOpaque(int32(sliceLen))
+		n += n2
+		if err != nil {
+			return n, err
+		}
+		v.SetBytes(data)
+		return n, nil
+	}
+
+	// Decode each slice element.
+	for i := 0; i < sliceLen; i++ {
+		n2, err := d.decode(v.Index(i))
+		n += n2
+		if err != nil {
+			return n, err
+		}
+	}
+	return n, nil
+}
+
+// decodeStruct treats the next bytes as a series of XDR encoded elements
+// of the same type as the exported fields of the struct represented by the
+// passed reflection value.  Pointers are automatically indirected and
+// allocated as necessary.  It returns the  the number of bytes actually read.
+//
+// An UnmarshalError is returned if any issues are encountered while decoding
+// the elements.
+//
+// Reference:
+// 	RFC Section 4.14 - Structure
+// 	XDR encoded elements in the order of their declaration in the struct
+func (d *Decoder) decodeStruct(v reflect.Value) (int, error) {
+	var n int
+	vt := v.Type()
+	for i := 0; i < v.NumField(); i++ {
+		// Skip unexported fields.
+		vtf := vt.Field(i)
+		if vtf.PkgPath != "" {
+			continue
+		}
+
+		// Indirect through pointers allocating them as needed and
+		// ensure the field is settable.
+		vf := v.Field(i)
+		vf, err := d.indirect(vf)
+		if err != nil {
+			return n, err
+		}
+		if !vf.CanSet() {
+			msg := fmt.Sprintf("can't decode to unsettable '%v'",
+				vf.Type().String())
+			err := unmarshalError("decodeStruct", ErrNotSettable,
+				msg, nil, nil)
+			return n, err
+		}
+
+		// Handle non-opaque data to []uint8 and [#]uint8 based on
+		// struct tag.
+		tag := vtf.Tag.Get("xdropaque")
+		if tag == "false" {
+			switch vf.Kind() {
+			case reflect.Slice:
+				n2, err := d.decodeArray(vf, true)
+				n += n2
+				if err != nil {
+					return n, err
+				}
+				continue
+
+			case reflect.Array:
+				n2, err := d.decodeFixedArray(vf, true)
+				n += n2
+				if err != nil {
+					return n, err
+				}
+				continue
+			}
+		}
+
+		// Decode each struct field.
+		n2, err := d.decode(vf)
+		n += n2
+		if err != nil {
+			return n, err
+		}
+	}
+
+	return n, nil
+}
+
+// RFC Section 4.15 - Discriminated Union
+// RFC Section 4.16 - Void
+// RFC Section 4.17 - Constant
+// RFC Section 4.18 - Typedef
+// RFC Section 4.19 - Optional data
+// RFC Sections 4.15 though 4.19 only apply to the data specification language
+// which is not implemented by this package.  In the case of discriminated
+// unions, struct tags are used to perform a similar function.
+
+// decodeMap treats the next bytes as an XDR encoded variable array of 2-element
+// structures whose fields are of the same type as the map keys and elements
+// represented by the passed reflection value.  Pointers are automatically
+// indirected and allocated as necessary.  It returns the  the number of bytes
+// actually read.
+//
+// An UnmarshalError is returned if any issues are encountered while decoding
+// the elements.
+func (d *Decoder) decodeMap(v reflect.Value) (int, error) {
+	dataLen, n, err := d.DecodeUint()
+	if err != nil {
+		return n, err
+	}
+
+	// Allocate storage for the underlying map if needed.
+	vt := v.Type()
+	if v.IsNil() {
+		v.Set(reflect.MakeMap(vt))
+	}
+
+	// Decode each key and value according to their type.
+	keyType := vt.Key()
+	elemType := vt.Elem()
+	for i := uint32(0); i < dataLen; i++ {
+		key := reflect.New(keyType).Elem()
+		n2, err := d.decode(key)
+		n += n2
+		if err != nil {
+			return n, err
+		}
+
+		val := reflect.New(elemType).Elem()
+		n2, err = d.decode(val)
+		n += n2
+		if err != nil {
+			return n, err
+		}
+		v.SetMapIndex(key, val)
+	}
+	return n, nil
+}
+
+// decodeInterface examines the interface represented by the passed reflection
+// value to detect whether it is an interface that can be decoded into and
+// if it is, extracts the underlying value to pass back into the decode function
+// for decoding according to its type.  It returns the  the number of bytes
+// actually read.
+//
+// An UnmarshalError is returned if any issues are encountered while decoding
+// the interface.
+func (d *Decoder) decodeInterface(v reflect.Value) (int, error) {
+	if v.IsNil() || !v.CanInterface() {
+		msg := fmt.Sprintf("can't decode to nil interface")
+		err := unmarshalError("decodeInterface", ErrNilInterface, msg,
+			nil, nil)
+		return 0, err
+	}
+
+	// Extract underlying value from the interface and indirect through
+	// pointers allocating them as needed.
+	ve := reflect.ValueOf(v.Interface())
+	ve, err := d.indirect(ve)
+	if err != nil {
+		return 0, err
+	}
+	if !ve.CanSet() {
+		msg := fmt.Sprintf("can't decode to unsettable '%v'",
+			ve.Type().String())
+		err := unmarshalError("decodeInterface", ErrNotSettable, msg,
+			nil, nil)
+		return 0, err
+	}
+	return d.decode(ve)
+}
+
+// decode is the main workhorse for unmarshalling via reflection.  It uses
+// the passed reflection value to choose the XDR primitives to decode from
+// the encapsulated reader.  It is a recursive function,
+// so cyclic data structures are not supported and will result in an infinite
+// loop.  It returns the  the number of bytes actually read.
+func (d *Decoder) decode(v reflect.Value) (int, error) {
+	if !v.IsValid() {
+		msg := fmt.Sprintf("type '%s' is not valid", v.Kind().String())
+		err := unmarshalError("decode", ErrUnsupportedType, msg, nil, nil)
+		return 0, err
+	}
+
+	// Indirect through pointers allocating them as needed.
+	ve, err := d.indirect(v)
+	if err != nil {
+		return 0, err
+	}
+
+	// Handle time.Time values by decoding them as an RFC3339 formatted
+	// string with nanosecond precision.  Check the type string rather
+	// than doing a full blown conversion to interface and type assertion
+	// since checking a string is much quicker.
+	switch ve.Type().String() {
+	case "time.Time":
+		// Read the value as a string and parse it.
+		timeString, n, err := d.DecodeString()
+		if err != nil {
+			return n, err
+		}
+		ttv, err := time.Parse(time.RFC3339, timeString)
+		if err != nil {
+			err := unmarshalError("decode", ErrParseTime,
+				err.Error(), timeString, err)
+			return n, err
+		}
+		ve.Set(reflect.ValueOf(ttv))
+		return n, nil
+	}
+	// If this type is in our custom types map, call the decode routine set up
+	// for it.
+	if dt, ok := d.customTypes[ve.Type().String()]; ok {
+		return dt.Decode(d, v)
+	}
+
+	// Handle native Go types.
+	switch ve.Kind() {
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int:
+		i, n, err := d.DecodeInt()
+		if err != nil {
+			return n, err
+		}
+		if ve.OverflowInt(int64(i)) {
+			msg := fmt.Sprintf("signed integer too large to fit '%s'",
+				ve.Kind().String())
+			err = unmarshalError("decode", ErrOverflow, msg, i, nil)
+			return n, err
+		}
+		ve.SetInt(int64(i))
+		return n, nil
+
+	case reflect.Int64:
+		i, n, err := d.DecodeHyper()
+		if err != nil {
+			return n, err
+		}
+		ve.SetInt(i)
+		return n, nil
+
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint:
+		ui, n, err := d.DecodeUint()
+		if err != nil {
+			return n, err
+		}
+		if ve.OverflowUint(uint64(ui)) {
+			msg := fmt.Sprintf("unsigned integer too large to fit '%s'",
+				ve.Kind().String())
+			err = unmarshalError("decode", ErrOverflow, msg, ui, nil)
+			return n, err
+		}
+		ve.SetUint(uint64(ui))
+		return n, nil
+
+	case reflect.Uint64:
+		ui, n, err := d.DecodeUhyper()
+		if err != nil {
+			return n, err
+		}
+		ve.SetUint(ui)
+		return n, nil
+
+	case reflect.Bool:
+		b, n, err := d.DecodeBool()
+		if err != nil {
+			return n, err
+		}
+		ve.SetBool(b)
+		return n, nil
+
+	case reflect.Float32:
+		f, n, err := d.DecodeFloat()
+		if err != nil {
+			return n, err
+		}
+		ve.SetFloat(float64(f))
+		return n, nil
+
+	case reflect.Float64:
+		f, n, err := d.DecodeDouble()
+		if err != nil {
+			return n, err
+		}
+		ve.SetFloat(f)
+		return n, nil
+
+	case reflect.String:
+		s, n, err := d.DecodeString()
+		if err != nil {
+			return n, err
+		}
+		ve.SetString(s)
+		return n, nil
+
+	case reflect.Array:
+		n, err := d.decodeFixedArray(ve, false)
+		if err != nil {
+			return n, err
+		}
+		return n, nil
+
+	case reflect.Slice:
+		n, err := d.decodeArray(ve, false)
+		if err != nil {
+			return n, err
+		}
+		return n, nil
+
+	case reflect.Struct:
+		n, err := d.decodeStruct(ve)
+		if err != nil {
+			return n, err
+		}
+		return n, nil
+
+	case reflect.Map:
+		n, err := d.decodeMap(ve)
+		if err != nil {
+			return n, err
+		}
+		return n, nil
+
+	case reflect.Interface:
+		n, err := d.decodeInterface(ve)
+		if err != nil {
+			return n, err
+		}
+		return n, nil
+	}
+
+	// The only unhandled types left are unsupported.  At the time of this
+	// writing the only remaining unsupported types that exist are
+	// reflect.Uintptr and reflect.UnsafePointer.
+	msg := fmt.Sprintf("unsupported Go type '%s'", ve.Kind().String())
+	err = unmarshalError("decode", ErrUnsupportedType, msg, nil, nil)
+	return 0, err
+}
+
+// indirect dereferences pointers allocating them as needed until it reaches
+// a non-pointer.  This allows transparent decoding through arbitrary levels
+// of indirection.
+func (d *Decoder) indirect(v reflect.Value) (reflect.Value, error) {
+	rv := v
+	for rv.Kind() == reflect.Ptr {
+		// Allocate pointer if needed.
+		isNil := rv.IsNil()
+		if isNil && !rv.CanSet() {
+			msg := fmt.Sprintf("unable to allocate pointer for '%v'",
+				rv.Type().String())
+			err := unmarshalError("indirect", ErrNotSettable, msg,
+				nil, nil)
+			return rv, err
+		}
+		if isNil {
+			rv.Set(reflect.New(rv.Type().Elem()))
+		}
+		rv = rv.Elem()
+	}
+	return rv, nil
+}
+
+// Decode operates identically to the Unmarshal function with the exception of
+// using the reader associated with the Decoder as the source of XDR-encoded
+// data instead of a user-supplied reader.  See the Unmarhsal documentation for
+// specifics.
+func (d *Decoder) Decode(v interface{}) (int, error) {
+	if v == nil {
+		msg := "can't unmarshal to nil interface"
+		return 0, unmarshalError("Unmarshal", ErrNilInterface, msg, nil,
+			nil)
+	}
+
+	vv := reflect.ValueOf(v)
+	if vv.Kind() != reflect.Ptr {
+		msg := fmt.Sprintf("can't unmarshal to non-pointer '%v' - use "+
+			"& operator", vv.Type().String())
+		err := unmarshalError("Unmarshal", ErrBadArguments, msg, nil, nil)
+		return 0, err
+	}
+	if vv.IsNil() && !vv.CanSet() {
+		msg := fmt.Sprintf("can't unmarshal to unsettable '%v' - use "+
+			"& operator", vv.Type().String())
+		err := unmarshalError("Unmarshal", ErrNotSettable, msg, nil, nil)
+		return 0, err
+	}
+
+	return d.decode(vv)
+}
+
+// NewDecoder returns a Decoder that can be used to manually decode XDR data
+// from a provided reader.  Typically, Unmarshal should be used instead of
+// manually creating a Decoder.
+func NewDecoder(r io.Reader) *Decoder {
+	return &Decoder{r: r}
+}
+
+// NewDecoderLimited is identical to NewDecoder but it sets maxReadSize in
+// order to cap reads.
+func NewDecoderLimited(r io.Reader, maxSize uint) *Decoder {
+	return &Decoder{r: r, maxReadSize: maxSize}
+}
+
+// NewDecoderCustomTypes returns a decoder with support for custom types known
+// to the caller. The second parameter is a map of the type name to the decoder
+// routine. When the decoder finds a type matching one of the entries in the map
+// it will call the custom routine for that type.
+func NewDecoderCustomTypes(r io.Reader, maxSize uint, ct map[string]TypeDecoder) *Decoder {
+	return &Decoder{r: r, maxReadSize: maxSize, customTypes: ct}
+}
diff --git a/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/doc.go b/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/doc.go
new file mode 100644
index 000000000..8823d62f3
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/doc.go
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) 2012-2014 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+Package xdr implements the data representation portion of the External Data
+Representation (XDR) standard protocol as specified in RFC 4506 (obsoletes
+RFC 1832 and RFC 1014).
+
+The XDR RFC defines both a data specification language and a data
+representation standard.  This package implements methods to encode and decode
+XDR data per the data representation standard with the exception of 128-bit
+quadruple-precision floating points.  It does not currently implement parsing of
+the data specification language.  In other words, the ability to automatically
+generate Go code by parsing an XDR data specification file (typically .x
+extension) is not supported.  In practice, this limitation of the package is
+fairly minor since it is largely unnecessary due to the reflection capabilities
+of Go as described below.
+
+This package provides two approaches for encoding and decoding XDR data:
+
+	1) Marshal/Unmarshal functions which automatically map between XDR and Go types
+	2) Individual Encoder/Decoder objects to manually work with XDR primitives
+
+For the Marshal/Unmarshal functions, Go reflection capabilities are used to
+choose the type of the underlying XDR data based upon the Go type to encode or
+the target Go type to decode into.  A description of how each type is mapped is
+provided below, however one important type worth reviewing is Go structs.  In
+the case of structs, each exported field (first letter capitalized) is reflected
+and mapped in order.  As a result, this means a Go struct with exported fields
+of the appropriate types listed in the expected order can be used to
+automatically encode / decode the XDR data thereby eliminating the need to write
+a lot of boilerplate code to encode/decode and error check each piece of XDR
+data as is typically required with C based XDR libraries.
+
+Go Type to XDR Type Mappings
+
+The following chart shows an overview of how Go types are mapped to XDR types
+for automatic marshalling and unmarshalling.  The documentation for the Marshal
+and Unmarshal functions has specific details of how the mapping proceeds.
+
+	Go Type <-> XDR Type
+	--------------------
+	int8, int16, int32, int <-> XDR Integer
+	uint8, uint16, uint32, uint <-> XDR Unsigned Integer
+	int64 <-> XDR Hyper Integer
+	uint64 <-> XDR Unsigned Hyper Integer
+	bool <-> XDR Boolean
+	float32 <-> XDR Floating-Point
+	float64 <-> XDR Double-Precision Floating-Point
+	string <-> XDR String
+	byte <-> XDR Integer
+	[]byte <-> XDR Variable-Length Opaque Data
+	[#]byte <-> XDR Fixed-Length Opaque Data
+	[]<type> <-> XDR Variable-Length Array
+	[#]<type> <-> XDR Fixed-Length Array
+	struct <-> XDR Structure
+	map <-> XDR Variable-Length Array of two-element XDR Structures
+	time.Time <-> XDR String encoded with RFC3339 nanosecond precision
+
+Notes and Limitations:
+
+	* Automatic marshalling and unmarshalling of variable and fixed-length
+	  arrays of uint8s require a special struct tag `xdropaque:"false"`
+	  since byte slices and byte arrays are assumed to be opaque data and
+	  byte is a Go alias for uint8 thus indistinguishable under reflection
+	* Channel, complex, and function types cannot be encoded
+	* Interfaces without a concrete value cannot be encoded
+	* Cyclic data structures are not supported and will result in infinite
+	  loops
+	* Strings are marshalled and unmarshalled with UTF-8 character encoding
+	  which differs from the XDR specification of ASCII, however UTF-8 is
+	  backwards compatible with ASCII so this should rarely cause issues
+
+
+Encoding
+
+To encode XDR data, use the Marshal function.
+	func Marshal(w io.Writer, v interface{}) (int, error)
+
+For example, given the following code snippet:
+
+	type ImageHeader struct {
+		Signature	[3]byte
+		Version		uint32
+		IsGrayscale	bool
+		NumSections	uint32
+	}
+	h := ImageHeader{[3]byte{0xAB, 0xCD, 0xEF}, 2, true, 10}
+
+	var w bytes.Buffer
+	bytesWritten, err := xdr.Marshal(&w, &h)
+	// Error check elided
+
+The result, encodedData, will then contain the following XDR encoded byte
+sequence:
+
+	0xAB, 0xCD, 0xEF, 0x00,
+	0x00, 0x00, 0x00, 0x02,
+	0x00, 0x00, 0x00, 0x01,
+	0x00, 0x00, 0x00, 0x0A
+
+
+In addition, while the automatic marshalling discussed above will work for the
+vast majority of cases, an Encoder object is provided that can be used to
+manually encode XDR primitives for complex scenarios where automatic
+reflection-based encoding won't work.  The included examples provide a sample of
+manual usage via an Encoder.
+
+
+Decoding
+
+To decode XDR data, use the Unmarshal function.
+	func Unmarshal(r io.Reader, v interface{}) (int, error)
+
+For example, given the following code snippet:
+
+	type ImageHeader struct {
+		Signature	[3]byte
+		Version		uint32
+		IsGrayscale	bool
+		NumSections	uint32
+	}
+
+	// Using output from the Encoding section above.
+	encodedData := []byte{
+		0xAB, 0xCD, 0xEF, 0x00,
+		0x00, 0x00, 0x00, 0x02,
+		0x00, 0x00, 0x00, 0x01,
+		0x00, 0x00, 0x00, 0x0A,
+	}
+
+	var h ImageHeader
+	bytesRead, err := xdr.Unmarshal(bytes.NewReader(encodedData), &h)
+	// Error check elided
+
+The struct instance, h, will then contain the following values:
+
+	h.Signature = [3]byte{0xAB, 0xCD, 0xEF}
+	h.Version = 2
+	h.IsGrayscale = true
+	h.NumSections = 10
+
+In addition, while the automatic unmarshalling discussed above will work for the
+vast majority of cases, a Decoder object is provided that can be used to
+manually decode XDR primitives for complex scenarios where automatic
+reflection-based decoding won't work.  The included examples provide a sample of
+manual usage via a Decoder.
+
+Errors
+
+All errors are either of type UnmarshalError or MarshalError.  Both provide
+human-readable output as well as an ErrorCode field which can be inspected by
+sophisticated callers if necessary.
+
+See the documentation of UnmarshalError, MarshalError, and ErrorCode for further
+details.
+*/
+package xdr
diff --git a/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/encode.go b/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/encode.go
new file mode 100644
index 000000000..7bac2681d
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/encode.go
@@ -0,0 +1,669 @@
+/*
+ * Copyright (c) 2012-2014 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package xdr
+
+import (
+	"fmt"
+	"io"
+	"math"
+	"reflect"
+	"time"
+)
+
+var errIOEncode = "%s while encoding %d bytes"
+
+/*
+Marshal writes the XDR encoding of v to writer w and returns the number of bytes
+written.  It traverses v recursively and automatically indirects pointers
+through arbitrary depth to encode the actual value pointed to.
+
+Marshal uses reflection to determine the type of the concrete value contained by
+v and performs a mapping of Go types to the underlying XDR types as follows:
+
+	Go Type -> XDR Type
+	--------------------
+	int8, int16, int32, int -> XDR Integer
+	uint8, uint16, uint32, uint -> XDR Unsigned Integer
+	int64 -> XDR Hyper Integer
+	uint64 -> XDR Unsigned Hyper Integer
+	bool -> XDR Boolean
+	float32 -> XDR Floating-Point
+	float64 -> XDR Double-Precision Floating-Point
+	string -> XDR String
+	byte -> XDR Integer
+	[]byte -> XDR Variable-Length Opaque Data
+	[#]byte -> XDR Fixed-Length Opaque Data
+	[]<type> -> XDR Variable-Length Array
+	[#]<type> -> XDR Fixed-Length Array
+	struct -> XDR Structure
+	map -> XDR Variable-Length Array of two-element XDR Structures
+	time.Time -> XDR String encoded with RFC3339 nanosecond precision
+
+Notes and Limitations:
+
+	* Automatic marshalling of variable and fixed-length arrays of uint8s
+	  requires a special struct tag `xdropaque:"false"` since byte slices and
+	  byte arrays are assumed to be opaque data and byte is a Go alias for uint8
+	  thus indistinguishable under reflection
+	* Channel, complex, and function types cannot be encoded
+	* Interfaces without a concrete value cannot be encoded
+	* Cyclic data structures are not supported and will result in infinite loops
+	* Strings are marshalled with UTF-8 character encoding which differs from
+	  the XDR specification of ASCII, however UTF-8 is backwards compatible with
+	  ASCII so this should rarely cause issues
+
+If any issues are encountered during the marshalling process, a MarshalError is
+returned with a human readable description as well as an ErrorCode value for
+further inspection from sophisticated callers.  Some potential issues are
+unsupported Go types, attempting to encode more opaque data than can be
+represented by a single opaque XDR entry, and exceeding max slice limitations.
+*/
+func Marshal(w io.Writer, v interface{}) (int, error) {
+	enc := Encoder{w: w}
+	return enc.Encode(v)
+}
+
+// An Encoder wraps an io.Writer that will receive the XDR encoded byte stream.
+// See NewEncoder.
+type Encoder struct {
+	w io.Writer
+}
+
+// EncodeInt writes the XDR encoded representation of the passed 32-bit signed
+// integer to the encapsulated writer and returns the number of bytes written.
+//
+// A MarshalError with an error code of ErrIO is returned if writing the data
+// fails.
+//
+// Reference:
+// 	RFC Section 4.1 - Integer
+// 	32-bit big-endian signed integer in range [-2147483648, 2147483647]
+func (enc *Encoder) EncodeInt(v int32) (int, error) {
+	var b [4]byte
+	b[0] = byte(v >> 24)
+	b[1] = byte(v >> 16)
+	b[2] = byte(v >> 8)
+	b[3] = byte(v)
+
+	n, err := enc.w.Write(b[:])
+	if err != nil {
+		msg := fmt.Sprintf(errIOEncode, err.Error(), 4)
+		err := marshalError("EncodeInt", ErrIO, msg, b[:n], err)
+		return n, err
+	}
+
+	return n, nil
+}
+
+// EncodeUint writes the XDR encoded representation of the passed 32-bit
+// unsigned integer to the encapsulated writer and returns the number of bytes
+// written.
+//
+// A MarshalError with an error code of ErrIO is returned if writing the data
+// fails.
+//
+// Reference:
+// 	RFC Section 4.2 - Unsigned Integer
+// 	32-bit big-endian unsigned integer in range [0, 4294967295]
+func (enc *Encoder) EncodeUint(v uint32) (int, error) {
+	var b [4]byte
+	b[0] = byte(v >> 24)
+	b[1] = byte(v >> 16)
+	b[2] = byte(v >> 8)
+	b[3] = byte(v)
+
+	n, err := enc.w.Write(b[:])
+	if err != nil {
+		msg := fmt.Sprintf(errIOEncode, err.Error(), 4)
+		err := marshalError("EncodeUint", ErrIO, msg, b[:n], err)
+		return n, err
+	}
+
+	return n, nil
+}
+
+// EncodeEnum treats the passed 32-bit signed integer as an enumeration value
+// and, if it is in the list of passed valid enumeration values, writes the XDR
+// encoded representation of it to the encapsulated writer.  It returns the
+// number of bytes written.
+//
+// A MarshalError is returned if the enumeration value is not one of the
+// provided valid values or if writing the data fails.
+//
+// Reference:
+// 	RFC Section 4.3 - Enumeration
+// 	Represented as an XDR encoded signed integer
+func (enc *Encoder) EncodeEnum(v int32, validEnums map[int32]bool) (int, error) {
+	if !validEnums[v] {
+		err := marshalError("EncodeEnum", ErrBadEnumValue,
+			"invalid enum", v, nil)
+		return 0, err
+	}
+	return enc.EncodeInt(v)
+}
+
+// EncodeBool writes the XDR encoded representation of the passed boolean to the
+// encapsulated writer and returns the number of bytes written.
+//
+// A MarshalError with an error code of ErrIO is returned if writing the data
+// fails.
+//
+// Reference:
+// 	RFC Section 4.4 - Boolean
+// 	Represented as an XDR encoded enumeration where 0 is false and 1 is true
+func (enc *Encoder) EncodeBool(v bool) (int, error) {
+	i := int32(0)
+	if v == true {
+		i = 1
+	}
+	return enc.EncodeInt(i)
+}
+
+// EncodeHyper writes the XDR encoded representation of the passed 64-bit
+// signed integer to the encapsulated writer and returns the number of bytes
+// written.
+//
+// A MarshalError with an error code of ErrIO is returned if writing the data
+// fails.
+//
+// Reference:
+// 	RFC Section 4.5 - Hyper Integer
+// 	64-bit big-endian signed integer in range [-9223372036854775808, 9223372036854775807]
+func (enc *Encoder) EncodeHyper(v int64) (int, error) {
+	var b [8]byte
+	b[0] = byte(v >> 56)
+	b[1] = byte(v >> 48)
+	b[2] = byte(v >> 40)
+	b[3] = byte(v >> 32)
+	b[4] = byte(v >> 24)
+	b[5] = byte(v >> 16)
+	b[6] = byte(v >> 8)
+	b[7] = byte(v)
+
+	n, err := enc.w.Write(b[:])
+	if err != nil {
+		msg := fmt.Sprintf(errIOEncode, err.Error(), 8)
+		err := marshalError("EncodeHyper", ErrIO, msg, b[:n], err)
+		return n, err
+	}
+
+	return n, nil
+}
+
+// EncodeUhyper writes the XDR encoded representation of the passed 64-bit
+// unsigned integer to the encapsulated writer and returns the number of bytes
+// written.
+//
+// A MarshalError with an error code of ErrIO is returned if writing the data
+// fails.
+//
+// Reference:
+// 	RFC Section 4.5 - Unsigned Hyper Integer
+// 	64-bit big-endian unsigned integer in range [0, 18446744073709551615]
+func (enc *Encoder) EncodeUhyper(v uint64) (int, error) {
+	var b [8]byte
+	b[0] = byte(v >> 56)
+	b[1] = byte(v >> 48)
+	b[2] = byte(v >> 40)
+	b[3] = byte(v >> 32)
+	b[4] = byte(v >> 24)
+	b[5] = byte(v >> 16)
+	b[6] = byte(v >> 8)
+	b[7] = byte(v)
+
+	n, err := enc.w.Write(b[:])
+	if err != nil {
+		msg := fmt.Sprintf(errIOEncode, err.Error(), 8)
+		err := marshalError("EncodeUhyper", ErrIO, msg, b[:n], err)
+		return n, err
+	}
+
+	return n, nil
+}
+
+// EncodeFloat writes the XDR encoded representation of the passed 32-bit
+// (single-precision) floating point to the encapsulated writer and returns the
+// number of bytes written.
+//
+// A MarshalError with an error code of ErrIO is returned if writing the data
+// fails.
+//
+// Reference:
+// 	RFC Section 4.6 - Floating Point
+// 	32-bit single-precision IEEE 754 floating point
+func (enc *Encoder) EncodeFloat(v float32) (int, error) {
+	ui := math.Float32bits(v)
+	return enc.EncodeUint(ui)
+}
+
+// EncodeDouble writes the XDR encoded representation of the passed 64-bit
+// (double-precision) floating point to the encapsulated writer and returns the
+// number of bytes written.
+//
+// A MarshalError with an error code of ErrIO is returned if writing the data
+// fails.
+//
+// Reference:
+// 	RFC Section 4.7 -  Double-Precision Floating Point
+// 	64-bit double-precision IEEE 754 floating point
+func (enc *Encoder) EncodeDouble(v float64) (int, error) {
+	ui := math.Float64bits(v)
+	return enc.EncodeUhyper(ui)
+}
+
+// RFC Section 4.8 -  Quadruple-Precision Floating Point
+// 128-bit quadruple-precision floating point
+// Not Implemented
+
+// EncodeFixedOpaque treats the passed byte slice as opaque data of a fixed
+// size and writes the XDR encoded representation of it  to the encapsulated
+// writer.  It returns the number of bytes written.
+//
+// A MarshalError with an error code of ErrIO is returned if writing the data
+// fails.
+//
+// Reference:
+// 	RFC Section 4.9 - Fixed-Length Opaque Data
+// 	Fixed-length uninterpreted data zero-padded to a multiple of four
+func (enc *Encoder) EncodeFixedOpaque(v []byte) (int, error) {
+	l := len(v)
+	pad := (4 - (l % 4)) % 4
+
+	// Write the actual bytes.
+	n, err := enc.w.Write(v)
+	if err != nil {
+		msg := fmt.Sprintf(errIOEncode, err.Error(), len(v))
+		err := marshalError("EncodeFixedOpaque", ErrIO, msg, v[:n], err)
+		return n, err
+	}
+
+	// Write any padding if needed.
+	if pad > 0 {
+		b := make([]byte, pad)
+		n2, err := enc.w.Write(b)
+		n += n2
+		if err != nil {
+			written := make([]byte, l+n2)
+			copy(written, v)
+			copy(written[l:], b[:n2])
+			msg := fmt.Sprintf(errIOEncode, err.Error(), l+pad)
+			err := marshalError("EncodeFixedOpaque", ErrIO, msg,
+				written, err)
+			return n, err
+		}
+	}
+
+	return n, nil
+}
+
+// EncodeOpaque treats the passed byte slice as opaque data of a variable
+// size and writes the XDR encoded representation of it to the encapsulated
+// writer.  It returns the number of bytes written.
+//
+// A MarshalError with an error code of ErrIO is returned if writing the data
+// fails.
+//
+// Reference:
+// 	RFC Section 4.10 - Variable-Length Opaque Data
+// 	Unsigned integer length followed by fixed opaque data of that length
+func (enc *Encoder) EncodeOpaque(v []byte) (int, error) {
+	// Length of opaque data.
+	n, err := enc.EncodeUint(uint32(len(v)))
+	if err != nil {
+		return n, err
+	}
+
+	n2, err := enc.EncodeFixedOpaque(v)
+	n += n2
+	return n, err
+}
+
+// EncodeString writes the XDR encoded representation of the passed string
+// to the encapsulated writer and returns the number of bytes written.
+// Character encoding is assumed to be UTF-8 and therefore ASCII compatible.  If
+// the underlying character encoding is not compatible with this assumption, the
+// data can instead be written as variable-length opaque data (EncodeOpaque) and
+// manually converted as needed.
+//
+// A MarshalError with an error code of ErrIO is returned if writing the data
+// fails.
+//
+// Reference:
+// 	RFC Section 4.11 - String
+// 	Unsigned integer length followed by bytes zero-padded to a multiple of four
+func (enc *Encoder) EncodeString(v string) (int, error) {
+	// Length of string.
+	n, err := enc.EncodeUint(uint32(len(v)))
+	if err != nil {
+		return n, err
+	}
+
+	n2, err := enc.EncodeFixedOpaque([]byte(v))
+	n += n2
+	return n, err
+}
+
+// encodeFixedArray writes the XDR encoded representation of each element
+// in the passed array represented by the reflection value to the encapsulated
+// writer and returns the number of bytes written.  The ignoreOpaque flag
+// controls whether or not uint8 (byte) elements should be encoded individually
+// or as a fixed sequence of opaque data.
+//
+// A MarshalError is returned if any issues are encountered while encoding
+// the array elements.
+//
+// Reference:
+// 	RFC Section 4.12 - Fixed-Length Array
+// 	Individually XDR encoded array elements
+func (enc *Encoder) encodeFixedArray(v reflect.Value, ignoreOpaque bool) (int, error) {
+	// Treat [#]byte (byte is alias for uint8) as opaque data unless ignored.
+	if !ignoreOpaque && v.Type().Elem().Kind() == reflect.Uint8 {
+		// Create a slice of the underlying array for better efficiency
+		// when possible.  Can't create a slice of an unaddressable
+		// value.
+		if v.CanAddr() {
+			return enc.EncodeFixedOpaque(v.Slice(0, v.Len()).Bytes())
+		}
+
+		// When the underlying array isn't addressable fall back to
+		// copying the array into a new slice.  This is rather ugly, but
+		// the inability to create a constant slice from an
+		// unaddressable array is a limitation of Go.
+		slice := make([]byte, v.Len(), v.Len())
+		reflect.Copy(reflect.ValueOf(slice), v)
+		return enc.EncodeFixedOpaque(slice)
+	}
+
+	// Encode each array element.
+	var n int
+	for i := 0; i < v.Len(); i++ {
+		n2, err := enc.encode(v.Index(i))
+		n += n2
+		if err != nil {
+			return n, err
+		}
+	}
+
+	return n, nil
+}
+
+// encodeArray writes an XDR encoded integer representing the number of
+// elements in the passed slice represented by the reflection value followed by
+// the XDR encoded representation of each element in slice to the encapsulated
+// writer and returns the number of bytes written.  The ignoreOpaque flag
+// controls whether or not uint8 (byte) elements should be encoded individually
+// or as a variable sequence of opaque data.
+//
+// A MarshalError is returned if any issues are encountered while encoding
+// the array elements.
+//
+// Reference:
+// 	RFC Section 4.13 - Variable-Length Array
+// 	Unsigned integer length followed by individually XDR encoded array elements
+func (enc *Encoder) encodeArray(v reflect.Value, ignoreOpaque bool) (int, error) {
+	numItems := uint32(v.Len())
+	n, err := enc.EncodeUint(numItems)
+	if err != nil {
+		return n, err
+	}
+
+	n2, err := enc.encodeFixedArray(v, ignoreOpaque)
+	n += n2
+	return n, err
+}
+
+// encodeStruct writes an XDR encoded representation of each value in the
+// exported fields of the struct represented by the passed reflection value to
+// the encapsulated writer and returns the number of bytes written.  Pointers
+// are automatically indirected through arbitrary depth to encode the actual
+// value pointed to.
+//
+// A MarshalError is returned if any issues are encountered while encoding
+// the elements.
+//
+// Reference:
+// 	RFC Section 4.14 - Structure
+// 	XDR encoded elements in the order of their declaration in the struct
+func (enc *Encoder) encodeStruct(v reflect.Value) (int, error) {
+	var n int
+	vt := v.Type()
+	for i := 0; i < v.NumField(); i++ {
+		// Skip unexported fields and indirect through pointers.
+		vtf := vt.Field(i)
+		if vtf.PkgPath != "" {
+			continue
+		}
+		vf := v.Field(i)
+		vf = enc.indirect(vf)
+
+		// Handle non-opaque data to []uint8 and [#]uint8 based on struct tag.
+		tag := vtf.Tag.Get("xdropaque")
+		if tag == "false" {
+			switch vf.Kind() {
+			case reflect.Slice:
+				n2, err := enc.encodeArray(vf, true)
+				n += n2
+				if err != nil {
+					return n, err
+				}
+				continue
+
+			case reflect.Array:
+				n2, err := enc.encodeFixedArray(vf, true)
+				n += n2
+				if err != nil {
+					return n, err
+				}
+				continue
+			}
+		}
+
+		// Encode each struct field.
+		n2, err := enc.encode(vf)
+		n += n2
+		if err != nil {
+			return n, err
+		}
+	}
+
+	return n, nil
+}
+
+// RFC Section 4.15 - Discriminated Union
+// RFC Section 4.16 - Void
+// RFC Section 4.17 - Constant
+// RFC Section 4.18 - Typedef
+// RFC Section 4.19 - Optional data
+// RFC Sections 4.15 though 4.19 only apply to the data specification language
+// which is not implemented by this package.  In the case of discriminated
+// unions, struct tags are used to perform a similar function.
+
+// encodeMap treats the map represented by the passed reflection value as a
+// variable-length array of 2-element structures whose fields are of the same
+// type as the map keys and elements and writes its XDR encoded representation
+// to the encapsulated writer.  It returns the number of bytes written.
+//
+// A MarshalError is returned if any issues are encountered while encoding
+// the elements.
+func (enc *Encoder) encodeMap(v reflect.Value) (int, error) {
+	// Number of elements.
+	n, err := enc.EncodeUint(uint32(v.Len()))
+	if err != nil {
+		return n, err
+	}
+
+	// Encode each key and value according to their type.
+	for _, key := range v.MapKeys() {
+		n2, err := enc.encode(key)
+		n += n2
+		if err != nil {
+			return n, err
+		}
+
+		n2, err = enc.encode(v.MapIndex(key))
+		n += n2
+		if err != nil {
+			return n, err
+		}
+	}
+
+	return n, nil
+}
+
+// encodeInterface examines the interface represented by the passed reflection
+// value to detect whether it is an interface that can be encoded if it is,
+// extracts the underlying value to pass back into the encode function for
+// encoding according to its type.
+//
+// A MarshalError is returned if any issues are encountered while encoding
+// the interface.
+func (enc *Encoder) encodeInterface(v reflect.Value) (int, error) {
+	if v.IsNil() || !v.CanInterface() {
+		msg := fmt.Sprintf("can't encode nil interface")
+		err := marshalError("encodeInterface", ErrNilInterface, msg,
+			nil, nil)
+		return 0, err
+	}
+
+	// Extract underlying value from the interface and indirect through pointers.
+	ve := reflect.ValueOf(v.Interface())
+	ve = enc.indirect(ve)
+	return enc.encode(ve)
+}
+
+// encode is the main workhorse for marshalling via reflection.  It uses
+// the passed reflection value to choose the XDR primitives to encode into
+// the encapsulated writer and returns the number of bytes written.  It is a
+// recursive function, so cyclic data structures are not supported and will
+// result in an infinite loop.
+func (enc *Encoder) encode(v reflect.Value) (int, error) {
+	if !v.IsValid() {
+		msg := fmt.Sprintf("type '%s' is not valid", v.Kind().String())
+		err := marshalError("encode", ErrUnsupportedType, msg, nil, nil)
+		return 0, err
+	}
+
+	// Indirect through pointers to get at the concrete value.
+	ve := enc.indirect(v)
+
+	// Handle time.Time values by encoding them as an RFC3339 formatted
+	// string with nanosecond precision.  Check the type string before
+	// doing a full blown conversion to interface and type assertion since
+	// checking a string is much quicker.
+	if ve.Type().String() == "time.Time" && ve.CanInterface() {
+		viface := ve.Interface()
+		if tv, ok := viface.(time.Time); ok {
+			return enc.EncodeString(tv.Format(time.RFC3339Nano))
+		}
+	}
+
+	// Handle native Go types.
+	switch ve.Kind() {
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int:
+		return enc.EncodeInt(int32(ve.Int()))
+
+	case reflect.Int64:
+		return enc.EncodeHyper(ve.Int())
+
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint:
+		return enc.EncodeUint(uint32(ve.Uint()))
+
+	case reflect.Uint64:
+		return enc.EncodeUhyper(ve.Uint())
+
+	case reflect.Bool:
+		return enc.EncodeBool(ve.Bool())
+
+	case reflect.Float32:
+		return enc.EncodeFloat(float32(ve.Float()))
+
+	case reflect.Float64:
+		return enc.EncodeDouble(ve.Float())
+
+	case reflect.String:
+		return enc.EncodeString(ve.String())
+
+	case reflect.Array:
+		return enc.encodeFixedArray(ve, false)
+
+	case reflect.Slice:
+		return enc.encodeArray(ve, false)
+
+	case reflect.Struct:
+		return enc.encodeStruct(ve)
+
+	case reflect.Map:
+		return enc.encodeMap(ve)
+
+	case reflect.Interface:
+		return enc.encodeInterface(ve)
+	}
+
+	// The only unhandled types left are unsupported.  At the time of this
+	// writing the only remaining unsupported types that exist are
+	// reflect.Uintptr and reflect.UnsafePointer.
+	msg := fmt.Sprintf("unsupported Go type '%s'", ve.Kind().String())
+	err := marshalError("encode", ErrUnsupportedType, msg, nil, nil)
+	return 0, err
+}
+
+// indirect dereferences pointers until it reaches a non-pointer.  This allows
+// transparent encoding through arbitrary levels of indirection.
+func (enc *Encoder) indirect(v reflect.Value) reflect.Value {
+	rv := v
+	for rv.Kind() == reflect.Ptr {
+		rv = rv.Elem()
+	}
+	return rv
+}
+
+// Encode operates identically to the Marshal function with the exception of
+// using the writer associated with the Encoder for the destination of the
+// XDR-encoded data instead of a user-supplied writer.  See the Marshal
+// documentation for specifics.
+func (enc *Encoder) Encode(v interface{}) (int, error) {
+	if v == nil {
+		msg := "can't marshal nil interface"
+		err := marshalError("Marshal", ErrNilInterface, msg, nil, nil)
+		return 0, err
+	}
+
+	vv := reflect.ValueOf(v)
+	vve := vv
+	for vve.Kind() == reflect.Ptr {
+		if vve.IsNil() {
+			msg := fmt.Sprintf("can't marshal nil pointer '%v'",
+				vv.Type().String())
+			err := marshalError("Marshal", ErrBadArguments, msg,
+				nil, nil)
+			return 0, err
+		}
+		vve = vve.Elem()
+	}
+
+	return enc.encode(vve)
+}
+
+// NewEncoder returns an object that can be used to manually choose fields to
+// XDR encode to the passed writer w.  Typically, Marshal should be used instead
+// of manually creating an Encoder. An Encoder, along with several of its
+// methods to encode XDR primitives, is exposed so it is possible to perform
+// manual encoding of data without relying on reflection should it be necessary
+// in complex scenarios where automatic reflection-based encoding won't work.
+func NewEncoder(w io.Writer) *Encoder {
+	return &Encoder{w: w}
+}
diff --git a/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/error.go b/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/error.go
new file mode 100644
index 000000000..42079ad35
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/error.go
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2012-2014 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package xdr
+
+import "fmt"
+
+// ErrorCode identifies a kind of error.
+type ErrorCode int
+
+const (
+	// ErrBadArguments indicates arguments passed to the function are not
+	// what was expected.
+	ErrBadArguments ErrorCode = iota
+
+	// ErrUnsupportedType indicates the Go type is not a supported type for
+	// marshalling and unmarshalling XDR data.
+	ErrUnsupportedType
+
+	// ErrBadEnumValue indicates an enumeration value is not in the list of
+	// valid values.
+	ErrBadEnumValue
+
+	// ErrNotSettable indicates an interface value cannot be written to.
+	// This usually means the interface value was not passed with the &
+	// operator, but it can also happen if automatic pointer allocation
+	// fails.
+	ErrNotSettable
+
+	// ErrOverflow indicates that the data in question is too large to fit
+	// into the corresponding Go or XDR data type.  For example, an integer
+	// decoded from XDR that is too large to fit into a target type of int8,
+	// or opaque data that exceeds the max length of a Go slice.
+	ErrOverflow
+
+	// ErrNilInterface indicates an interface with no concrete type
+	// information was encountered.  Type information is necessary to
+	// perform mapping between XDR and Go types.
+	ErrNilInterface
+
+	// ErrIO indicates an error was encountered while reading or writing to
+	// an io.Reader or io.Writer, respectively.  The actual underlying error
+	// will be available via the Err field of the MarshalError or
+	// UnmarshalError struct.
+	ErrIO
+
+	// ErrParseTime indicates an error was encountered while parsing an
+	// RFC3339 formatted time value.  The actual underlying error will be
+	// available via the Err field of the UnmarshalError struct.
+	ErrParseTime
+)
+
+// Map of ErrorCode values back to their constant names for pretty printing.
+var errorCodeStrings = map[ErrorCode]string{
+	ErrBadArguments:    "ErrBadArguments",
+	ErrUnsupportedType: "ErrUnsupportedType",
+	ErrBadEnumValue:    "ErrBadEnumValue",
+	ErrNotSettable:     "ErrNotSettable",
+	ErrOverflow:        "ErrOverflow",
+	ErrNilInterface:    "ErrNilInterface",
+	ErrIO:              "ErrIO",
+	ErrParseTime:       "ErrParseTime",
+}
+
+// String returns the ErrorCode as a human-readable name.
+func (e ErrorCode) String() string {
+	if s := errorCodeStrings[e]; s != "" {
+		return s
+	}
+	return fmt.Sprintf("Unknown ErrorCode (%d)", e)
+}
+
+// UnmarshalError describes a problem encountered while unmarshaling data.
+// Some potential issues are unsupported Go types, attempting to decode a value
+// which is too large to fit into a specified Go type, and exceeding max slice
+// limitations.
+type UnmarshalError struct {
+	ErrorCode   ErrorCode   // Describes the kind of error
+	Func        string      // Function name
+	Value       interface{} // Value actually parsed where appropriate
+	Description string      // Human readable description of the issue
+	Err         error       // The underlying error for IO errors
+}
+
+// Error satisfies the error interface and prints human-readable errors.
+func (e *UnmarshalError) Error() string {
+	switch e.ErrorCode {
+	case ErrBadEnumValue, ErrOverflow, ErrIO, ErrParseTime:
+		return fmt.Sprintf("xdr:%s: %s - read: '%v'", e.Func,
+			e.Description, e.Value)
+	}
+	return fmt.Sprintf("xdr:%s: %s", e.Func, e.Description)
+}
+
+// unmarshalError creates an error given a set of arguments and will copy byte
+// slices into the Value field since they might otherwise be changed from from
+// the original value.
+func unmarshalError(f string, c ErrorCode, desc string, v interface{}, err error) *UnmarshalError {
+	e := &UnmarshalError{ErrorCode: c, Func: f, Description: desc, Err: err}
+	switch t := v.(type) {
+	case []byte:
+		slice := make([]byte, len(t))
+		copy(slice, t)
+		e.Value = slice
+	default:
+		e.Value = v
+	}
+
+	return e
+}
+
+// IsIO returns a boolean indicating whether the error is known to report that
+// the underlying reader or writer encountered an ErrIO.
+func IsIO(err error) bool {
+	switch e := err.(type) {
+	case *UnmarshalError:
+		return e.ErrorCode == ErrIO
+	case *MarshalError:
+		return e.ErrorCode == ErrIO
+	}
+	return false
+}
+
+// MarshalError describes a problem encountered while marshaling data.
+// Some potential issues are unsupported Go types, attempting to encode more
+// opaque data than can be represented by a single opaque XDR entry, and
+// exceeding max slice limitations.
+type MarshalError struct {
+	ErrorCode   ErrorCode   // Describes the kind of error
+	Func        string      // Function name
+	Value       interface{} // Value actually parsed where appropriate
+	Description string      // Human readable description of the issue
+	Err         error       // The underlying error for IO errors
+}
+
+// Error satisfies the error interface and prints human-readable errors.
+func (e *MarshalError) Error() string {
+	switch e.ErrorCode {
+	case ErrIO:
+		return fmt.Sprintf("xdr:%s: %s - wrote: '%v'", e.Func,
+			e.Description, e.Value)
+	case ErrBadEnumValue:
+		return fmt.Sprintf("xdr:%s: %s - value: '%v'", e.Func,
+			e.Description, e.Value)
+	}
+	return fmt.Sprintf("xdr:%s: %s", e.Func, e.Description)
+}
+
+// marshalError creates an error given a set of arguments and will copy byte
+// slices into the Value field since they might otherwise be changed from from
+// the original value.
+func marshalError(f string, c ErrorCode, desc string, v interface{}, err error) *MarshalError {
+	e := &MarshalError{ErrorCode: c, Func: f, Description: desc, Err: err}
+	switch t := v.(type) {
+	case []byte:
+		slice := make([]byte, len(t))
+		copy(slice, t)
+		e.Value = slice
+	default:
+		e.Value = v
+	}
+
+	return e
+}
diff --git a/vendor/github.com/digitalocean/go-libvirt/libvirt.go b/vendor/github.com/digitalocean/go-libvirt/libvirt.go
new file mode 100644
index 000000000..a76eafdd2
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/libvirt.go
@@ -0,0 +1,608 @@
+// Copyright 2018 The go-libvirt Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package libvirt is a pure Go implementation of the libvirt RPC protocol.
+// For more information on the protocol, see https://libvirt.org/internals/l.html
+package libvirt
+
+// We'll use c-for-go to extract the consts and typedefs from the libvirt
+// sources so we don't have to duplicate them here.
+//go:generate scripts/gen-consts.sh
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net"
+	"sync"
+
+	"github.com/digitalocean/go-libvirt/internal/constants"
+	"github.com/digitalocean/go-libvirt/internal/event"
+	xdr "github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2"
+)
+
+// ErrEventsNotSupported is returned by Events() if event streams
+// are unsupported by either QEMU or libvirt.
+var ErrEventsNotSupported = errors.New("event monitor is not supported")
+
+// Libvirt implements libvirt's remote procedure call protocol.
+type Libvirt struct {
+	conn net.Conn
+	r    *bufio.Reader
+	w    *bufio.Writer
+	mu   *sync.Mutex
+
+	// method callbacks
+	cmux      sync.RWMutex
+	callbacks map[int32]chan response
+
+	// event listeners
+	emux   sync.RWMutex
+	events map[int32]*event.Stream
+
+	// next request serial number
+	s int32
+}
+
+// DomainEvent represents a libvirt domain event.
+type DomainEvent struct {
+	CallbackID   int32
+	Domain       Domain
+	Event        string
+	Seconds      uint64
+	Microseconds uint32
+	Padding      uint8
+	Details      []byte
+}
+
+// GetCallbackID returns the callback ID of a QEMU domain event.
+func (de DomainEvent) GetCallbackID() int32 {
+	return de.CallbackID
+}
+
+// GetCallbackID returns the callback ID of a libvirt lifecycle event.
+func (m DomainEventCallbackLifecycleMsg) GetCallbackID() int32 {
+	return m.CallbackID
+}
+
+// qemuError represents a QEMU process error.
+type qemuError struct {
+	Error struct {
+		Class       string `json:"class"`
+		Description string `json:"desc"`
+	} `json:"error"`
+}
+
+// Capabilities returns an XML document describing the host's capabilties.
+func (l *Libvirt) Capabilities() ([]byte, error) {
+	caps, err := l.ConnectGetCapabilities()
+	return []byte(caps), err
+}
+
+// Connect establishes communication with the libvirt server.
+// The underlying libvirt socket connection must be previously established.
+func (l *Libvirt) Connect() error {
+	payload := struct {
+		Padding [3]byte
+		Name    string
+		Flags   uint32
+	}{
+		Padding: [3]byte{0x1, 0x0, 0x0},
+		Name:    "qemu:///system",
+		Flags:   0,
+	}
+
+	buf, err := encode(&payload)
+	if err != nil {
+		return err
+	}
+
+	// libvirt requires that we call auth-list prior to connecting,
+	// event when no authentication is used.
+	_, err = l.request(constants.ProcAuthList, constants.Program, buf)
+	if err != nil {
+		return err
+	}
+
+	_, err = l.request(constants.ProcConnectOpen, constants.Program, buf)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Disconnect shuts down communication with the libvirt server and closes the
+// underlying net.Conn.
+func (l *Libvirt) Disconnect() error {
+	// close event streams
+	for _, ev := range l.events {
+		l.unsubscribeEvents(ev)
+	}
+
+	// Deregister all callbacks to prevent blocking on clients with
+	// outstanding requests
+	l.deregisterAll()
+
+	_, err := l.request(constants.ProcConnectClose, constants.Program, nil)
+	if err != nil {
+		return err
+	}
+
+	return l.conn.Close()
+}
+
+// Domains returns a list of all domains managed by libvirt.
+//
+// Deprecated: use ConnectListAllDomains instead.
+func (l *Libvirt) Domains() ([]Domain, error) {
+	// these are the flags as passed by `virsh list --all`
+	flags := ConnectListDomainsActive | ConnectListDomainsInactive
+	domains, _, err := l.ConnectListAllDomains(1, flags)
+	return domains, err
+}
+
+// DomainState returns state of the domain managed by libvirt.
+//
+// Deprecated: use DomainGetState instead.
+func (l *Libvirt) DomainState(dom string) (DomainState, error) {
+	d, err := l.lookup(dom)
+	if err != nil {
+		return DomainNostate, err
+	}
+
+	state, _, err := l.DomainGetState(d, 0)
+	return DomainState(state), err
+}
+
+// SubscribeQEMUEvents streams domain events until the provided context is
+// cancelled. If a problem is encountered setting up the event monitor
+// connection an error will be returned. Errors encountered during streaming
+// will cause the returned event channel to be closed. QEMU domain events.
+func (l *Libvirt) SubscribeQEMUEvents(ctx context.Context, dom string) (<-chan DomainEvent, error) {
+	d, err := l.lookup(dom)
+	if err != nil {
+		return nil, err
+	}
+
+	callbackID, err := l.QEMUConnectDomainMonitorEventRegister([]Domain{d}, nil, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	stream := event.NewStream(constants.QEMUProgram, callbackID)
+	l.addStream(stream)
+	ch := make(chan DomainEvent)
+	go func() {
+		ctx, cancel := context.WithCancel(ctx)
+		defer cancel()
+		defer l.unsubscribeQEMUEvents(stream)
+		defer stream.Shutdown()
+		defer func() { close(ch) }()
+
+		for {
+			select {
+			case ev, ok := <-stream.Recv():
+				if !ok {
+					return
+				}
+				ch <- *ev.(*DomainEvent)
+			case <-ctx.Done():
+				return
+			}
+		}
+	}()
+
+	return ch, nil
+}
+
+// unsubscribeQEMUEvents stops the flow of events from QEMU through libvirt.
+func (l *Libvirt) unsubscribeQEMUEvents(stream *event.Stream) error {
+	err := l.QEMUConnectDomainMonitorEventDeregister(stream.CallbackID)
+	l.removeStream(stream.CallbackID)
+
+	return err
+}
+
+// SubscribeEvents allows the caller to subscribe to any of the event types
+// supported by libvirt. The events will continue to be streamed until the
+// caller cancels the provided context. After canceling the context, callers
+// should wait until the channel is closed to be sure they're collected all the
+// events.
+func (l *Libvirt) SubscribeEvents(ctx context.Context, eventID DomainEventID,
+	dom OptDomain) (<-chan interface{}, error) {
+
+	callbackID, err := l.ConnectDomainEventCallbackRegisterAny(int32(eventID), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	stream := event.NewStream(constants.QEMUProgram, callbackID)
+	l.addStream(stream)
+
+	ch := make(chan interface{})
+	go func() {
+		ctx, cancel := context.WithCancel(ctx)
+		defer cancel()
+		defer l.unsubscribeEvents(stream)
+		defer stream.Shutdown()
+		defer func() { close(ch) }()
+
+		for {
+			select {
+			case ev, ok := <-stream.Recv():
+				if !ok {
+					return
+				}
+				ch <- ev
+			case <-ctx.Done():
+				return
+			}
+		}
+	}()
+
+	return ch, nil
+}
+
+// unsubscribeEvents stops the flow of the specified events from libvirt. There
+// are two steps to this process: a call to libvirt to deregister our callback,
+// and then removing the callback from the list used by the `route` fucntion. If
+// the deregister call fails, we'll return the error, but still remove the
+// callback from the list. That's ok; if any events arrive after this point, the
+// route function will drop them when it finds no registered handler.
+func (l *Libvirt) unsubscribeEvents(stream *event.Stream) error {
+	err := l.ConnectDomainEventCallbackDeregisterAny(stream.CallbackID)
+	l.removeStream(stream.CallbackID)
+
+	return err
+}
+
+// LifecycleEvents streams lifecycle events until the provided context is
+// cancelled. If a problem is encountered setting up the event monitor
+// connection, an error will be returned. Errors encountered during streaming
+// will cause the returned event channel to be closed.
+func (l *Libvirt) LifecycleEvents(ctx context.Context) (<-chan DomainEventLifecycleMsg, error) {
+	callbackID, err := l.ConnectDomainEventCallbackRegisterAny(int32(DomainEventIDLifecycle), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	stream := event.NewStream(constants.Program, callbackID)
+	l.addStream(stream)
+
+	ch := make(chan DomainEventLifecycleMsg)
+
+	go func() {
+		ctx, cancel := context.WithCancel(ctx)
+		defer cancel()
+		defer l.unsubscribeEvents(stream)
+		defer stream.Shutdown()
+		defer func() { close(ch) }()
+
+		for {
+			select {
+			case ev, ok := <-stream.Recv():
+				if !ok {
+					return
+				}
+				ch <- ev.(*DomainEventCallbackLifecycleMsg).Msg
+			case <-ctx.Done():
+				return
+			}
+		}
+	}()
+
+	return ch, nil
+}
+
+// Run executes the given QAPI command against a domain's QEMU instance.
+// For a list of available QAPI commands, see:
+//	http://git.qemu.org/?p=qemu.git;a=blob;f=qapi-schema.json;hb=HEAD
+func (l *Libvirt) Run(dom string, cmd []byte) ([]byte, error) {
+	d, err := l.lookup(dom)
+	if err != nil {
+		return nil, err
+	}
+
+	payload := struct {
+		Domain  Domain
+		Command []byte
+		Flags   uint32
+	}{
+		Domain:  d,
+		Command: cmd,
+		Flags:   0,
+	}
+
+	buf, err := encode(&payload)
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := l.request(constants.QEMUProcDomainMonitorCommand, constants.QEMUProgram, buf)
+	if err != nil {
+		return nil, err
+	}
+
+	// check for QEMU process errors
+	if err = getQEMUError(res); err != nil {
+		return nil, err
+	}
+
+	r := bytes.NewReader(res.Payload)
+	dec := xdr.NewDecoder(r)
+	data, _, err := dec.DecodeFixedOpaque(int32(r.Len()))
+	if err != nil {
+		return nil, err
+	}
+
+	// drop QMP control characters from start of line, and drop
+	// any trailing NULL characters from the end
+	return bytes.TrimRight(data[4:], "\x00"), nil
+}
+
+// Secrets returns all secrets managed by the libvirt daemon.
+//
+// Deprecated: use ConnectListAllSecrets instead.
+func (l *Libvirt) Secrets() ([]Secret, error) {
+	secrets, _, err := l.ConnectListAllSecrets(1, 0)
+	return secrets, err
+}
+
+// StoragePool returns the storage pool associated with the provided name.
+// An error is returned if the requested storage pool is not found.
+//
+// Deprecated: use StoragePoolLookupByName instead.
+func (l *Libvirt) StoragePool(name string) (StoragePool, error) {
+	return l.StoragePoolLookupByName(name)
+}
+
+// StoragePools returns a list of defined storage pools. Pools are filtered by
+// the provided flags. See StoragePools*.
+//
+// Deprecated: use ConnectListAllStoragePools instead.
+func (l *Libvirt) StoragePools(flags ConnectListAllStoragePoolsFlags) ([]StoragePool, error) {
+	pools, _, err := l.ConnectListAllStoragePools(1, flags)
+	return pools, err
+}
+
+// Undefine undefines the domain specified by dom, e.g., 'prod-lb-01'.
+// The flags argument allows additional options to be specified such as
+// cleaning up snapshot metadata. For more information on available
+// flags, see DomainUndefine*.
+//
+// Deprecated: use DomainUndefineFlags instead.
+func (l *Libvirt) Undefine(dom string, flags DomainUndefineFlagsValues) error {
+	d, err := l.lookup(dom)
+	if err != nil {
+		return err
+	}
+
+	return l.DomainUndefineFlags(d, flags)
+}
+
+// Destroy destroys the domain specified by dom, e.g., 'prod-lb-01'.
+// The flags argument allows additional options to be specified such as
+// allowing a graceful shutdown with SIGTERM than SIGKILL.
+// For more information on available flags, see DomainDestroy*.
+//
+// Deprecated: use DomainDestroyFlags instead.
+func (l *Libvirt) Destroy(dom string, flags DomainDestroyFlagsValues) error {
+	d, err := l.lookup(dom)
+	if err != nil {
+		return err
+	}
+
+	return l.DomainDestroyFlags(d, flags)
+}
+
+// XML returns a domain's raw XML definition, akin to `virsh dumpxml <domain>`.
+// See DomainXMLFlag* for optional flags.
+//
+// Deprecated: use DomainGetXMLDesc instead.
+func (l *Libvirt) XML(dom string, flags DomainXMLFlags) ([]byte, error) {
+	d, err := l.lookup(dom)
+	if err != nil {
+		return nil, err
+	}
+
+	xml, err := l.DomainGetXMLDesc(d, flags)
+	return []byte(xml), err
+}
+
+// DefineXML defines a domain, but does not start it.
+//
+// Deprecated: use DomainDefineXMLFlags instead.
+func (l *Libvirt) DefineXML(x []byte, flags DomainDefineFlags) error {
+	_, err := l.DomainDefineXMLFlags(string(x), flags)
+	return err
+}
+
+// Version returns the version of the libvirt daemon.
+//
+// Deprecated: use ConnectGetLibVersion instead.
+func (l *Libvirt) Version() (string, error) {
+	ver, err := l.ConnectGetLibVersion()
+	if err != nil {
+		return "", err
+	}
+
+	// The version is provided as an int following this formula:
+	// version * 1,000,000 + minor * 1000 + micro
+	// See src/libvirt-host.c # virConnectGetLibVersion
+	major := ver / 1000000
+	ver %= 1000000
+	minor := ver / 1000
+	ver %= 1000
+	micro := ver
+
+	versionString := fmt.Sprintf("%d.%d.%d", major, minor, micro)
+	return versionString, nil
+}
+
+// Shutdown shuts down a domain. Note that the guest OS may ignore the request.
+// If flags is set to 0 then the hypervisor will choose the method of shutdown it considers best.
+//
+// Deprecated: use DomainShutdownFlags instead.
+func (l *Libvirt) Shutdown(dom string, flags DomainShutdownFlagValues) error {
+	d, err := l.lookup(dom)
+	if err != nil {
+		return err
+	}
+
+	return l.DomainShutdownFlags(d, flags)
+}
+
+// Reboot reboots the domain. Note that the guest OS may ignore the request.
+// If flags is set to zero, then the hypervisor will choose the method of shutdown it considers best.
+//
+// Deprecated: use DomainReboot instead.
+func (l *Libvirt) Reboot(dom string, flags DomainRebootFlagValues) error {
+	d, err := l.lookup(dom)
+	if err != nil {
+		return err
+	}
+
+	return l.DomainReboot(d, flags)
+}
+
+// Reset resets domain immediately without any guest OS shutdown
+//
+// Deprecated: use DomainReset instead.
+func (l *Libvirt) Reset(dom string) error {
+	d, err := l.lookup(dom)
+	if err != nil {
+		return err
+	}
+
+	return l.DomainReset(d, 0)
+}
+
+// BlockLimit contains a name and value pair for a Get/SetBlockIOTune limit. The
+// Name field is the name of the limit (to see a list of the limits that can be
+// applied, execute the 'blkdeviotune' command on a VM in virsh). Callers can
+// use the QEMUBlockIO... constants below for the Name value. The Value field is
+// the limit to apply.
+type BlockLimit struct {
+	Name  string
+	Value uint64
+}
+
+// SetBlockIOTune changes the per-device block I/O tunables within a guest.
+// Parameters are the name of the VM, the name of the disk device to which the
+// limits should be applied, and 1 or more BlockLimit structs containing the
+// actual limits.
+//
+// The limits which can be applied here are enumerated in the QEMUBlockIO...
+// constants above, and you can also see the full list by executing the
+// 'blkdeviotune' command on a VM in virsh.
+//
+// Example usage:
+//  SetBlockIOTune("vm-name", "vda", BlockLimit{libvirt.QEMUBlockIOWriteBytesSec, 1000000})
+//
+// Deprecated: use DomainSetBlockIOTune instead.
+func (l *Libvirt) SetBlockIOTune(dom string, disk string, limits ...BlockLimit) error {
+	d, err := l.lookup(dom)
+	if err != nil {
+		return err
+	}
+
+	params := make([]TypedParam, len(limits))
+	for ix, limit := range limits {
+		tpval := NewTypedParamValueUllong(limit.Value)
+		params[ix] = TypedParam{Field: limit.Name, Value: *tpval}
+	}
+
+	return l.DomainSetBlockIOTune(d, disk, params, uint32(DomainAffectLive))
+}
+
+// GetBlockIOTune returns a slice containing the current block I/O tunables for
+// a disk.
+//
+// Deprecated: use DomainGetBlockIOTune instead.
+func (l *Libvirt) GetBlockIOTune(dom string, disk string) ([]BlockLimit, error) {
+	d, err := l.lookup(dom)
+	if err != nil {
+		return nil, err
+	}
+
+	lims, _, err := l.DomainGetBlockIOTune(d, []string{disk}, 32, uint32(TypedParamStringOkay))
+	if err != nil {
+		return nil, err
+	}
+
+	var limits []BlockLimit
+
+	// now decode each of the returned TypedParams. To do this we read the field
+	// name and type, then use the type information to decode the value.
+	for _, lim := range lims {
+		var l BlockLimit
+		name := lim.Field
+		switch lim.Value.I.(type) {
+		case uint64:
+			l = BlockLimit{Name: name, Value: lim.Value.I.(uint64)}
+		}
+		limits = append(limits, l)
+	}
+
+	return limits, nil
+}
+
+// lookup returns a domain as seen by libvirt.
+func (l *Libvirt) lookup(name string) (Domain, error) {
+	return l.DomainLookupByName(name)
+}
+
+// getQEMUError checks the provided response for QEMU process errors.
+// If an error is found, it is extracted an returned, otherwise nil.
+func getQEMUError(r response) error {
+	pl := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoder(pl)
+
+	s, _, err := dec.DecodeString()
+	if err != nil {
+		return err
+	}
+
+	var e qemuError
+	if err = json.Unmarshal([]byte(s), &e); err != nil {
+		return err
+	}
+
+	if e.Error.Description != "" {
+		return errors.New(e.Error.Description)
+	}
+
+	return nil
+}
+
+// New configures a new Libvirt RPC connection.
+func New(conn net.Conn) *Libvirt {
+	l := &Libvirt{
+		conn:      conn,
+		s:         0,
+		r:         bufio.NewReader(conn),
+		w:         bufio.NewWriter(conn),
+		mu:        &sync.Mutex{},
+		callbacks: make(map[int32]chan response),
+		events:    make(map[int32]*event.Stream),
+	}
+
+	go l.listen()
+
+	return l
+}
diff --git a/vendor/github.com/digitalocean/go-libvirt/libvirt.yml b/vendor/github.com/digitalocean/go-libvirt/libvirt.yml
new file mode 100644
index 000000000..4d6cc2d50
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/libvirt.yml
@@ -0,0 +1,64 @@
+# Configuration file for c-for-go, which go-libvirt uses to translate the const
+# and type definitions from the C-language sources in the libvirt project into
+# Go. This file is used by the c-for-go binary (github.com/xlab/c-for-go), which
+# is called when 'go generate' is run. See libvirt.go for the command line used.
+---
+GENERATOR:
+    PackageName: libvirt
+    PackageLicense: |
+        Copyright 2018 The go-libvirt Authors.
+
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+    Includes: []
+
+PARSER:
+    # We can't use environment variables here, but we don't want to process the
+    # libvirt version installed in the system folders (if any). Instead we'll
+    # rely on our caller to link the libvirt source directory to lv_source/, and
+    # run on that code. This isn't ideal, but changes to c-for-go are needed to
+    # fix it.
+    IncludePaths: [./lv_source/include]
+    SourcesPaths:
+        - libvirt/libvirt.h
+        - libvirt/virterror.h
+
+TRANSLATOR:
+    ConstRules:
+        defines: eval
+    Rules:
+        global:
+            - {action: accept, from: "^vir"}
+        post-global:
+            - {action: replace, from: "^vir"}
+            - {load: snakecase}
+            # Follow golint's capitalization conventions.
+            - {action: replace, from: "Api([A-Z]|$)", to: "API$1"}
+            - {action: replace, from: "Cpu([A-Z]|$)", to: "CPU$1"}
+            - {action: replace, from: "Dns([A-Z]|$)", to: "DNS$1"}
+            - {action: replace, from: "Eof([A-Z]|$)", to: "EOF$1"}
+            - {action: replace, from: "Id([A-Z]|$)", to: "ID$1"}
+            - {action: replace, from: "Ip([A-Z]|$)", to: "IP$1"}
+            - {action: replace, from: "Tls([A-Z]|$)", to: "TLS$1"}
+            - {action: replace, from: "Uuid([A-Z]|$)", to: "UUID$1"}
+            - {action: replace, from: "Uri([A-Z]|$)", to: "URI$1"}
+            - {action: replace, from: "Vcpu([A-Z]|$)", to: "VCPU$1"}
+            - {action: replace, from: "Xml([A-Z]|$)", to: "XML$1"}
+            - {action: replace, from: "Rpc([A-Z]|$)", to: "RPC$1"}
+            - {action: replace, from: "Ssh([A-Z]|$)", to: "SSH$1"}
+            - {action: replace, from: "Http([A-Z]|$)", to: "HTTP$1"}
+            - {transform: unexport, from: "^(Err|From|War)"}
+        const:
+            - {action: accept, from: "^VIR_"}
+            # Special case to prevent a collision with a type:
+            - {action: replace, from: "^VIR_DOMAIN_JOB_OPERATION", to: "VIR_DOMAIN_JOB_OPERATION_STR"}
+            - {transform: lower}
diff --git a/vendor/github.com/digitalocean/go-libvirt/libvirtd.conf b/vendor/github.com/digitalocean/go-libvirt/libvirtd.conf
new file mode 100644
index 000000000..d416d7ba3
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/libvirtd.conf
@@ -0,0 +1,7 @@
+# libvirtd configuration for travis-ci
+listen_tls = 0
+listen_tcp = 1
+tcp_port = "16509"
+listen_addr = "127.0.0.1"
+auth_unix_rw = "none"
+auth_tcp = "none"
diff --git a/vendor/github.com/digitalocean/go-libvirt/qemu_protocol.gen.go b/vendor/github.com/digitalocean/go-libvirt/qemu_protocol.gen.go
new file mode 100644
index 000000000..7666a63cd
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/qemu_protocol.gen.go
@@ -0,0 +1,292 @@
+// Copyright 2018 The go-libvirt Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//
+// Code generated by internal/lvgen/generate.go. DO NOT EDIT.
+//
+// To regenerate, run 'go generate' in internal/lvgen.
+//
+
+package libvirt
+
+import (
+	"bytes"
+	"io"
+
+	"github.com/digitalocean/go-libvirt/internal/constants"
+	"github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2"
+)
+
+// References to prevent "imported and not used" errors.
+var (
+	_ = bytes.Buffer{}
+	_ = io.Copy
+	_ = constants.Program
+	_ = xdr.Unmarshal
+)
+
+//
+// Typedefs:
+//
+
+//
+// Enums:
+//
+// QEMUProcedure is libvirt's qemu_procedure
+type QEMUProcedure int32
+
+//
+// Structs:
+//
+// QEMUDomainMonitorCommandArgs is libvirt's qemu_domain_monitor_command_args
+type QEMUDomainMonitorCommandArgs struct {
+	Dom Domain
+	Cmd string
+	Flags uint32
+}
+
+// QEMUDomainMonitorCommandRet is libvirt's qemu_domain_monitor_command_ret
+type QEMUDomainMonitorCommandRet struct {
+	Result string
+}
+
+// QEMUDomainAttachArgs is libvirt's qemu_domain_attach_args
+type QEMUDomainAttachArgs struct {
+	PidValue uint32
+	Flags uint32
+}
+
+// QEMUDomainAttachRet is libvirt's qemu_domain_attach_ret
+type QEMUDomainAttachRet struct {
+	Dom Domain
+}
+
+// QEMUDomainAgentCommandArgs is libvirt's qemu_domain_agent_command_args
+type QEMUDomainAgentCommandArgs struct {
+	Dom Domain
+	Cmd string
+	Timeout int32
+	Flags uint32
+}
+
+// QEMUDomainAgentCommandRet is libvirt's qemu_domain_agent_command_ret
+type QEMUDomainAgentCommandRet struct {
+	Result OptString
+}
+
+// QEMUConnectDomainMonitorEventRegisterArgs is libvirt's qemu_connect_domain_monitor_event_register_args
+type QEMUConnectDomainMonitorEventRegisterArgs struct {
+	Dom OptDomain
+	Event OptString
+	Flags uint32
+}
+
+// QEMUConnectDomainMonitorEventRegisterRet is libvirt's qemu_connect_domain_monitor_event_register_ret
+type QEMUConnectDomainMonitorEventRegisterRet struct {
+	CallbackID int32
+}
+
+// QEMUConnectDomainMonitorEventDeregisterArgs is libvirt's qemu_connect_domain_monitor_event_deregister_args
+type QEMUConnectDomainMonitorEventDeregisterArgs struct {
+	CallbackID int32
+}
+
+// QEMUDomainMonitorEventMsg is libvirt's qemu_domain_monitor_event_msg
+type QEMUDomainMonitorEventMsg struct {
+	CallbackID int32
+	Dom Domain
+	Event string
+	Seconds int64
+	Micros uint32
+	Details OptString
+}
+
+
+
+
+// QEMUDomainMonitorCommand is the go wrapper for QEMU_PROC_DOMAIN_MONITOR_COMMAND.
+func (l *Libvirt) QEMUDomainMonitorCommand(Dom Domain, Cmd string, Flags uint32) (rResult string, err error) {
+	var buf []byte
+
+	args := QEMUDomainMonitorCommandArgs {
+		Dom: Dom,
+		Cmd: Cmd,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(1, constants.QEMUProgram, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Result: string
+	_, err = dec.Decode(&rResult)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// QEMUDomainAttach is the go wrapper for QEMU_PROC_DOMAIN_ATTACH.
+func (l *Libvirt) QEMUDomainAttach(PidValue uint32, Flags uint32) (rDom Domain, err error) {
+	var buf []byte
+
+	args := QEMUDomainAttachArgs {
+		PidValue: PidValue,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(2, constants.QEMUProgram, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Dom: Domain
+	_, err = dec.Decode(&rDom)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// QEMUDomainAgentCommand is the go wrapper for QEMU_PROC_DOMAIN_AGENT_COMMAND.
+func (l *Libvirt) QEMUDomainAgentCommand(Dom Domain, Cmd string, Timeout int32, Flags uint32) (rResult OptString, err error) {
+	var buf []byte
+
+	args := QEMUDomainAgentCommandArgs {
+		Dom: Dom,
+		Cmd: Cmd,
+		Timeout: Timeout,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(3, constants.QEMUProgram, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Result: OptString
+	_, err = dec.Decode(&rResult)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// QEMUConnectDomainMonitorEventRegister is the go wrapper for QEMU_PROC_CONNECT_DOMAIN_MONITOR_EVENT_REGISTER.
+func (l *Libvirt) QEMUConnectDomainMonitorEventRegister(Dom OptDomain, Event OptString, Flags uint32) (rCallbackID int32, err error) {
+	var buf []byte
+
+	args := QEMUConnectDomainMonitorEventRegisterArgs {
+		Dom: Dom,
+		Event: Event,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(4, constants.QEMUProgram, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// CallbackID: int32
+	_, err = dec.Decode(&rCallbackID)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// QEMUConnectDomainMonitorEventDeregister is the go wrapper for QEMU_PROC_CONNECT_DOMAIN_MONITOR_EVENT_DEREGISTER.
+func (l *Libvirt) QEMUConnectDomainMonitorEventDeregister(CallbackID int32) (err error) {
+	var buf []byte
+
+	args := QEMUConnectDomainMonitorEventDeregisterArgs {
+		CallbackID: CallbackID,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(5, constants.QEMUProgram, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// QEMUDomainMonitorEvent is the go wrapper for QEMU_PROC_DOMAIN_MONITOR_EVENT.
+func (l *Libvirt) QEMUDomainMonitorEvent() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(6, constants.QEMUProgram, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
diff --git a/vendor/github.com/digitalocean/go-libvirt/remote_protocol.gen.go b/vendor/github.com/digitalocean/go-libvirt/remote_protocol.gen.go
new file mode 100644
index 000000000..0021e866e
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/remote_protocol.gen.go
@@ -0,0 +1,16449 @@
+// Copyright 2018 The go-libvirt Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//
+// Code generated by internal/lvgen/generate.go. DO NOT EDIT.
+//
+// To regenerate, run 'go generate' in internal/lvgen.
+//
+
+package libvirt
+
+import (
+	"bytes"
+	"io"
+
+	"github.com/digitalocean/go-libvirt/internal/constants"
+	"github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2"
+)
+
+// References to prevent "imported and not used" errors.
+var (
+	_ = bytes.Buffer{}
+	_ = io.Copy
+	_ = constants.Program
+	_ = xdr.Unmarshal
+)
+
+//
+// Typedefs:
+//
+// OptString is libvirt's remote_string
+type OptString []string
+// UUID is libvirt's remote_uuid
+type UUID [UUIDBuflen]byte
+// OptDomain is libvirt's remote_domain
+type OptDomain []Domain
+// OptNetwork is libvirt's remote_network
+type OptNetwork []Network
+// OptNetworkPort is libvirt's remote_network_port
+type OptNetworkPort []NetworkPort
+// OptNwfilter is libvirt's remote_nwfilter
+type OptNwfilter []Nwfilter
+// OptNwfilterBinding is libvirt's remote_nwfilter_binding
+type OptNwfilterBinding []NwfilterBinding
+// OptStoragePool is libvirt's remote_storage_pool
+type OptStoragePool []StoragePool
+// OptStorageVol is libvirt's remote_storage_vol
+type OptStorageVol []StorageVol
+// OptNodeDevice is libvirt's remote_node_device
+type OptNodeDevice []NodeDevice
+// OptSecret is libvirt's remote_secret
+type OptSecret []Secret
+
+//
+// Enums:
+//
+// AuthType is libvirt's remote_auth_type
+type AuthType int32
+// Procedure is libvirt's remote_procedure
+type Procedure int32
+
+//
+// Structs:
+//
+// Domain is libvirt's remote_nonnull_domain
+type Domain struct {
+	Name string
+	UUID UUID
+	ID int32
+}
+
+// Network is libvirt's remote_nonnull_network
+type Network struct {
+	Name string
+	UUID UUID
+}
+
+// NetworkPort is libvirt's remote_nonnull_network_port
+type NetworkPort struct {
+	Net Network
+	UUID UUID
+}
+
+// Nwfilter is libvirt's remote_nonnull_nwfilter
+type Nwfilter struct {
+	Name string
+	UUID UUID
+}
+
+// NwfilterBinding is libvirt's remote_nonnull_nwfilter_binding
+type NwfilterBinding struct {
+	Portdev string
+	Filtername string
+}
+
+// Interface is libvirt's remote_nonnull_interface
+type Interface struct {
+	Name string
+	Mac string
+}
+
+// StoragePool is libvirt's remote_nonnull_storage_pool
+type StoragePool struct {
+	Name string
+	UUID UUID
+}
+
+// StorageVol is libvirt's remote_nonnull_storage_vol
+type StorageVol struct {
+	Pool string
+	Name string
+	Key string
+}
+
+// NodeDevice is libvirt's remote_nonnull_node_device
+type NodeDevice struct {
+	Name string
+}
+
+// Secret is libvirt's remote_nonnull_secret
+type Secret struct {
+	UUID UUID
+	UsageType int32
+	UsageID string
+}
+
+// DomainCheckpoint is libvirt's remote_nonnull_domain_checkpoint
+type DomainCheckpoint struct {
+	Name string
+	Dom Domain
+}
+
+// DomainSnapshot is libvirt's remote_nonnull_domain_snapshot
+type DomainSnapshot struct {
+	Name string
+	Dom Domain
+}
+
+// Error is libvirt's remote_error
+type Error struct {
+	Code int32
+	OptDomain int32
+	Message OptString
+	Level int32
+	Dom OptDomain
+	Str1 OptString
+	Str2 OptString
+	Str3 OptString
+	Int1 int32
+	Int2 int32
+	Net OptNetwork
+}
+
+// VcpuInfo is libvirt's remote_vcpu_info
+type VcpuInfo struct {
+	Number uint32
+	State int32
+	CPUTime uint64
+	CPU int32
+}
+
+// TypedParam is libvirt's remote_typed_param
+type TypedParam struct {
+	Field string
+	Value TypedParamValue
+}
+
+// NodeGetCPUStats is libvirt's remote_node_get_cpu_stats
+type NodeGetCPUStats struct {
+	Field string
+	Value uint64
+}
+
+// NodeGetMemoryStats is libvirt's remote_node_get_memory_stats
+type NodeGetMemoryStats struct {
+	Field string
+	Value uint64
+}
+
+// DomainDiskError is libvirt's remote_domain_disk_error
+type DomainDiskError struct {
+	Disk string
+	Error int32
+}
+
+// ConnectOpenArgs is libvirt's remote_connect_open_args
+type ConnectOpenArgs struct {
+	Name OptString
+	Flags ConnectFlags
+}
+
+// ConnectSupportsFeatureArgs is libvirt's remote_connect_supports_feature_args
+type ConnectSupportsFeatureArgs struct {
+	Feature int32
+}
+
+// ConnectSupportsFeatureRet is libvirt's remote_connect_supports_feature_ret
+type ConnectSupportsFeatureRet struct {
+	Supported int32
+}
+
+// ConnectGetTypeRet is libvirt's remote_connect_get_type_ret
+type ConnectGetTypeRet struct {
+	Type string
+}
+
+// ConnectGetVersionRet is libvirt's remote_connect_get_version_ret
+type ConnectGetVersionRet struct {
+	HvVer uint64
+}
+
+// ConnectGetLibVersionRet is libvirt's remote_connect_get_lib_version_ret
+type ConnectGetLibVersionRet struct {
+	LibVer uint64
+}
+
+// ConnectGetHostnameRet is libvirt's remote_connect_get_hostname_ret
+type ConnectGetHostnameRet struct {
+	Hostname string
+}
+
+// ConnectGetSysinfoArgs is libvirt's remote_connect_get_sysinfo_args
+type ConnectGetSysinfoArgs struct {
+	Flags uint32
+}
+
+// ConnectGetSysinfoRet is libvirt's remote_connect_get_sysinfo_ret
+type ConnectGetSysinfoRet struct {
+	Sysinfo string
+}
+
+// ConnectGetUriRet is libvirt's remote_connect_get_uri_ret
+type ConnectGetUriRet struct {
+	Uri string
+}
+
+// ConnectGetMaxVcpusArgs is libvirt's remote_connect_get_max_vcpus_args
+type ConnectGetMaxVcpusArgs struct {
+	Type OptString
+}
+
+// ConnectGetMaxVcpusRet is libvirt's remote_connect_get_max_vcpus_ret
+type ConnectGetMaxVcpusRet struct {
+	MaxVcpus int32
+}
+
+// NodeGetInfoRet is libvirt's remote_node_get_info_ret
+type NodeGetInfoRet struct {
+	Model [32]int8
+	Memory uint64
+	Cpus int32
+	Mhz int32
+	Nodes int32
+	Sockets int32
+	Cores int32
+	Threads int32
+}
+
+// ConnectGetCapabilitiesRet is libvirt's remote_connect_get_capabilities_ret
+type ConnectGetCapabilitiesRet struct {
+	Capabilities string
+}
+
+// ConnectGetDomainCapabilitiesArgs is libvirt's remote_connect_get_domain_capabilities_args
+type ConnectGetDomainCapabilitiesArgs struct {
+	Emulatorbin OptString
+	Arch OptString
+	Machine OptString
+	Virttype OptString
+	Flags uint32
+}
+
+// ConnectGetDomainCapabilitiesRet is libvirt's remote_connect_get_domain_capabilities_ret
+type ConnectGetDomainCapabilitiesRet struct {
+	Capabilities string
+}
+
+// NodeGetCPUStatsArgs is libvirt's remote_node_get_cpu_stats_args
+type NodeGetCPUStatsArgs struct {
+	CPUNum int32
+	Nparams int32
+	Flags uint32
+}
+
+// NodeGetCPUStatsRet is libvirt's remote_node_get_cpu_stats_ret
+type NodeGetCPUStatsRet struct {
+	Params []NodeGetCPUStats
+	Nparams int32
+}
+
+// NodeGetMemoryStatsArgs is libvirt's remote_node_get_memory_stats_args
+type NodeGetMemoryStatsArgs struct {
+	Nparams int32
+	CellNum int32
+	Flags uint32
+}
+
+// NodeGetMemoryStatsRet is libvirt's remote_node_get_memory_stats_ret
+type NodeGetMemoryStatsRet struct {
+	Params []NodeGetMemoryStats
+	Nparams int32
+}
+
+// NodeGetCellsFreeMemoryArgs is libvirt's remote_node_get_cells_free_memory_args
+type NodeGetCellsFreeMemoryArgs struct {
+	StartCell int32
+	Maxcells int32
+}
+
+// NodeGetCellsFreeMemoryRet is libvirt's remote_node_get_cells_free_memory_ret
+type NodeGetCellsFreeMemoryRet struct {
+	Cells []uint64
+}
+
+// NodeGetFreeMemoryRet is libvirt's remote_node_get_free_memory_ret
+type NodeGetFreeMemoryRet struct {
+	FreeMem uint64
+}
+
+// DomainGetSchedulerTypeArgs is libvirt's remote_domain_get_scheduler_type_args
+type DomainGetSchedulerTypeArgs struct {
+	Dom Domain
+}
+
+// DomainGetSchedulerTypeRet is libvirt's remote_domain_get_scheduler_type_ret
+type DomainGetSchedulerTypeRet struct {
+	Type string
+	Nparams int32
+}
+
+// DomainGetSchedulerParametersArgs is libvirt's remote_domain_get_scheduler_parameters_args
+type DomainGetSchedulerParametersArgs struct {
+	Dom Domain
+	Nparams int32
+}
+
+// DomainGetSchedulerParametersRet is libvirt's remote_domain_get_scheduler_parameters_ret
+type DomainGetSchedulerParametersRet struct {
+	Params []TypedParam
+}
+
+// DomainGetSchedulerParametersFlagsArgs is libvirt's remote_domain_get_scheduler_parameters_flags_args
+type DomainGetSchedulerParametersFlagsArgs struct {
+	Dom Domain
+	Nparams int32
+	Flags uint32
+}
+
+// DomainGetSchedulerParametersFlagsRet is libvirt's remote_domain_get_scheduler_parameters_flags_ret
+type DomainGetSchedulerParametersFlagsRet struct {
+	Params []TypedParam
+}
+
+// DomainSetSchedulerParametersArgs is libvirt's remote_domain_set_scheduler_parameters_args
+type DomainSetSchedulerParametersArgs struct {
+	Dom Domain
+	Params []TypedParam
+}
+
+// DomainSetSchedulerParametersFlagsArgs is libvirt's remote_domain_set_scheduler_parameters_flags_args
+type DomainSetSchedulerParametersFlagsArgs struct {
+	Dom Domain
+	Params []TypedParam
+	Flags uint32
+}
+
+// DomainSetBlkioParametersArgs is libvirt's remote_domain_set_blkio_parameters_args
+type DomainSetBlkioParametersArgs struct {
+	Dom Domain
+	Params []TypedParam
+	Flags uint32
+}
+
+// DomainGetBlkioParametersArgs is libvirt's remote_domain_get_blkio_parameters_args
+type DomainGetBlkioParametersArgs struct {
+	Dom Domain
+	Nparams int32
+	Flags uint32
+}
+
+// DomainGetBlkioParametersRet is libvirt's remote_domain_get_blkio_parameters_ret
+type DomainGetBlkioParametersRet struct {
+	Params []TypedParam
+	Nparams int32
+}
+
+// DomainSetMemoryParametersArgs is libvirt's remote_domain_set_memory_parameters_args
+type DomainSetMemoryParametersArgs struct {
+	Dom Domain
+	Params []TypedParam
+	Flags uint32
+}
+
+// DomainGetMemoryParametersArgs is libvirt's remote_domain_get_memory_parameters_args
+type DomainGetMemoryParametersArgs struct {
+	Dom Domain
+	Nparams int32
+	Flags uint32
+}
+
+// DomainGetMemoryParametersRet is libvirt's remote_domain_get_memory_parameters_ret
+type DomainGetMemoryParametersRet struct {
+	Params []TypedParam
+	Nparams int32
+}
+
+// DomainBlockResizeArgs is libvirt's remote_domain_block_resize_args
+type DomainBlockResizeArgs struct {
+	Dom Domain
+	Disk string
+	Size uint64
+	Flags DomainBlockResizeFlags
+}
+
+// DomainSetNumaParametersArgs is libvirt's remote_domain_set_numa_parameters_args
+type DomainSetNumaParametersArgs struct {
+	Dom Domain
+	Params []TypedParam
+	Flags uint32
+}
+
+// DomainGetNumaParametersArgs is libvirt's remote_domain_get_numa_parameters_args
+type DomainGetNumaParametersArgs struct {
+	Dom Domain
+	Nparams int32
+	Flags uint32
+}
+
+// DomainGetNumaParametersRet is libvirt's remote_domain_get_numa_parameters_ret
+type DomainGetNumaParametersRet struct {
+	Params []TypedParam
+	Nparams int32
+}
+
+// DomainSetPerfEventsArgs is libvirt's remote_domain_set_perf_events_args
+type DomainSetPerfEventsArgs struct {
+	Dom Domain
+	Params []TypedParam
+	Flags DomainModificationImpact
+}
+
+// DomainGetPerfEventsArgs is libvirt's remote_domain_get_perf_events_args
+type DomainGetPerfEventsArgs struct {
+	Dom Domain
+	Flags DomainModificationImpact
+}
+
+// DomainGetPerfEventsRet is libvirt's remote_domain_get_perf_events_ret
+type DomainGetPerfEventsRet struct {
+	Params []TypedParam
+}
+
+// DomainBlockStatsArgs is libvirt's remote_domain_block_stats_args
+type DomainBlockStatsArgs struct {
+	Dom Domain
+	Path string
+}
+
+// DomainBlockStatsRet is libvirt's remote_domain_block_stats_ret
+type DomainBlockStatsRet struct {
+	RdReq int64
+	RdBytes int64
+	WrReq int64
+	WrBytes int64
+	Errs int64
+}
+
+// DomainBlockStatsFlagsArgs is libvirt's remote_domain_block_stats_flags_args
+type DomainBlockStatsFlagsArgs struct {
+	Dom Domain
+	Path string
+	Nparams int32
+	Flags uint32
+}
+
+// DomainBlockStatsFlagsRet is libvirt's remote_domain_block_stats_flags_ret
+type DomainBlockStatsFlagsRet struct {
+	Params []TypedParam
+	Nparams int32
+}
+
+// DomainInterfaceStatsArgs is libvirt's remote_domain_interface_stats_args
+type DomainInterfaceStatsArgs struct {
+	Dom Domain
+	Device string
+}
+
+// DomainInterfaceStatsRet is libvirt's remote_domain_interface_stats_ret
+type DomainInterfaceStatsRet struct {
+	RxBytes int64
+	RxPackets int64
+	RxErrs int64
+	RxDrop int64
+	TxBytes int64
+	TxPackets int64
+	TxErrs int64
+	TxDrop int64
+}
+
+// DomainSetInterfaceParametersArgs is libvirt's remote_domain_set_interface_parameters_args
+type DomainSetInterfaceParametersArgs struct {
+	Dom Domain
+	Device string
+	Params []TypedParam
+	Flags uint32
+}
+
+// DomainGetInterfaceParametersArgs is libvirt's remote_domain_get_interface_parameters_args
+type DomainGetInterfaceParametersArgs struct {
+	Dom Domain
+	Device string
+	Nparams int32
+	Flags DomainModificationImpact
+}
+
+// DomainGetInterfaceParametersRet is libvirt's remote_domain_get_interface_parameters_ret
+type DomainGetInterfaceParametersRet struct {
+	Params []TypedParam
+	Nparams int32
+}
+
+// DomainMemoryStatsArgs is libvirt's remote_domain_memory_stats_args
+type DomainMemoryStatsArgs struct {
+	Dom Domain
+	MaxStats uint32
+	Flags uint32
+}
+
+// DomainMemoryStat is libvirt's remote_domain_memory_stat
+type DomainMemoryStat struct {
+	Tag int32
+	Val uint64
+}
+
+// DomainMemoryStatsRet is libvirt's remote_domain_memory_stats_ret
+type DomainMemoryStatsRet struct {
+	Stats []DomainMemoryStat
+}
+
+// DomainBlockPeekArgs is libvirt's remote_domain_block_peek_args
+type DomainBlockPeekArgs struct {
+	Dom Domain
+	Path string
+	Offset uint64
+	Size uint32
+	Flags uint32
+}
+
+// DomainBlockPeekRet is libvirt's remote_domain_block_peek_ret
+type DomainBlockPeekRet struct {
+	Buffer []byte
+}
+
+// DomainMemoryPeekArgs is libvirt's remote_domain_memory_peek_args
+type DomainMemoryPeekArgs struct {
+	Dom Domain
+	Offset uint64
+	Size uint32
+	Flags DomainMemoryFlags
+}
+
+// DomainMemoryPeekRet is libvirt's remote_domain_memory_peek_ret
+type DomainMemoryPeekRet struct {
+	Buffer []byte
+}
+
+// DomainGetBlockInfoArgs is libvirt's remote_domain_get_block_info_args
+type DomainGetBlockInfoArgs struct {
+	Dom Domain
+	Path string
+	Flags uint32
+}
+
+// DomainGetBlockInfoRet is libvirt's remote_domain_get_block_info_ret
+type DomainGetBlockInfoRet struct {
+	Allocation uint64
+	Capacity uint64
+	Physical uint64
+}
+
+// ConnectListDomainsArgs is libvirt's remote_connect_list_domains_args
+type ConnectListDomainsArgs struct {
+	Maxids int32
+}
+
+// ConnectListDomainsRet is libvirt's remote_connect_list_domains_ret
+type ConnectListDomainsRet struct {
+	Ids []int32
+}
+
+// ConnectNumOfDomainsRet is libvirt's remote_connect_num_of_domains_ret
+type ConnectNumOfDomainsRet struct {
+	Num int32
+}
+
+// DomainCreateXMLArgs is libvirt's remote_domain_create_xml_args
+type DomainCreateXMLArgs struct {
+	XMLDesc string
+	Flags DomainCreateFlags
+}
+
+// DomainCreateXMLRet is libvirt's remote_domain_create_xml_ret
+type DomainCreateXMLRet struct {
+	Dom Domain
+}
+
+// DomainCreateXMLWithFilesArgs is libvirt's remote_domain_create_xml_with_files_args
+type DomainCreateXMLWithFilesArgs struct {
+	XMLDesc string
+	Flags DomainCreateFlags
+}
+
+// DomainCreateXMLWithFilesRet is libvirt's remote_domain_create_xml_with_files_ret
+type DomainCreateXMLWithFilesRet struct {
+	Dom Domain
+}
+
+// DomainLookupByIDArgs is libvirt's remote_domain_lookup_by_id_args
+type DomainLookupByIDArgs struct {
+	ID int32
+}
+
+// DomainLookupByIDRet is libvirt's remote_domain_lookup_by_id_ret
+type DomainLookupByIDRet struct {
+	Dom Domain
+}
+
+// DomainLookupByUUIDArgs is libvirt's remote_domain_lookup_by_uuid_args
+type DomainLookupByUUIDArgs struct {
+	UUID UUID
+}
+
+// DomainLookupByUUIDRet is libvirt's remote_domain_lookup_by_uuid_ret
+type DomainLookupByUUIDRet struct {
+	Dom Domain
+}
+
+// DomainLookupByNameArgs is libvirt's remote_domain_lookup_by_name_args
+type DomainLookupByNameArgs struct {
+	Name string
+}
+
+// DomainLookupByNameRet is libvirt's remote_domain_lookup_by_name_ret
+type DomainLookupByNameRet struct {
+	Dom Domain
+}
+
+// DomainSuspendArgs is libvirt's remote_domain_suspend_args
+type DomainSuspendArgs struct {
+	Dom Domain
+}
+
+// DomainResumeArgs is libvirt's remote_domain_resume_args
+type DomainResumeArgs struct {
+	Dom Domain
+}
+
+// DomainPmSuspendForDurationArgs is libvirt's remote_domain_pm_suspend_for_duration_args
+type DomainPmSuspendForDurationArgs struct {
+	Dom Domain
+	Target uint32
+	Duration uint64
+	Flags uint32
+}
+
+// DomainPmWakeupArgs is libvirt's remote_domain_pm_wakeup_args
+type DomainPmWakeupArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainShutdownArgs is libvirt's remote_domain_shutdown_args
+type DomainShutdownArgs struct {
+	Dom Domain
+}
+
+// DomainRebootArgs is libvirt's remote_domain_reboot_args
+type DomainRebootArgs struct {
+	Dom Domain
+	Flags DomainRebootFlagValues
+}
+
+// DomainResetArgs is libvirt's remote_domain_reset_args
+type DomainResetArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainDestroyArgs is libvirt's remote_domain_destroy_args
+type DomainDestroyArgs struct {
+	Dom Domain
+}
+
+// DomainDestroyFlagsArgs is libvirt's remote_domain_destroy_flags_args
+type DomainDestroyFlagsArgs struct {
+	Dom Domain
+	Flags DomainDestroyFlagsValues
+}
+
+// DomainGetOsTypeArgs is libvirt's remote_domain_get_os_type_args
+type DomainGetOsTypeArgs struct {
+	Dom Domain
+}
+
+// DomainGetOsTypeRet is libvirt's remote_domain_get_os_type_ret
+type DomainGetOsTypeRet struct {
+	Type string
+}
+
+// DomainGetMaxMemoryArgs is libvirt's remote_domain_get_max_memory_args
+type DomainGetMaxMemoryArgs struct {
+	Dom Domain
+}
+
+// DomainGetMaxMemoryRet is libvirt's remote_domain_get_max_memory_ret
+type DomainGetMaxMemoryRet struct {
+	Memory uint64
+}
+
+// DomainSetMaxMemoryArgs is libvirt's remote_domain_set_max_memory_args
+type DomainSetMaxMemoryArgs struct {
+	Dom Domain
+	Memory uint64
+}
+
+// DomainSetMemoryArgs is libvirt's remote_domain_set_memory_args
+type DomainSetMemoryArgs struct {
+	Dom Domain
+	Memory uint64
+}
+
+// DomainSetMemoryFlagsArgs is libvirt's remote_domain_set_memory_flags_args
+type DomainSetMemoryFlagsArgs struct {
+	Dom Domain
+	Memory uint64
+	Flags uint32
+}
+
+// DomainSetMemoryStatsPeriodArgs is libvirt's remote_domain_set_memory_stats_period_args
+type DomainSetMemoryStatsPeriodArgs struct {
+	Dom Domain
+	Period int32
+	Flags DomainMemoryModFlags
+}
+
+// DomainGetInfoArgs is libvirt's remote_domain_get_info_args
+type DomainGetInfoArgs struct {
+	Dom Domain
+}
+
+// DomainGetInfoRet is libvirt's remote_domain_get_info_ret
+type DomainGetInfoRet struct {
+	State uint8
+	MaxMem uint64
+	Memory uint64
+	NrVirtCPU uint16
+	CPUTime uint64
+}
+
+// DomainSaveArgs is libvirt's remote_domain_save_args
+type DomainSaveArgs struct {
+	Dom Domain
+	To string
+}
+
+// DomainSaveFlagsArgs is libvirt's remote_domain_save_flags_args
+type DomainSaveFlagsArgs struct {
+	Dom Domain
+	To string
+	Dxml OptString
+	Flags uint32
+}
+
+// DomainRestoreArgs is libvirt's remote_domain_restore_args
+type DomainRestoreArgs struct {
+	From string
+}
+
+// DomainRestoreFlagsArgs is libvirt's remote_domain_restore_flags_args
+type DomainRestoreFlagsArgs struct {
+	From string
+	Dxml OptString
+	Flags uint32
+}
+
+// DomainSaveImageGetXMLDescArgs is libvirt's remote_domain_save_image_get_xml_desc_args
+type DomainSaveImageGetXMLDescArgs struct {
+	File string
+	Flags uint32
+}
+
+// DomainSaveImageGetXMLDescRet is libvirt's remote_domain_save_image_get_xml_desc_ret
+type DomainSaveImageGetXMLDescRet struct {
+	XML string
+}
+
+// DomainSaveImageDefineXMLArgs is libvirt's remote_domain_save_image_define_xml_args
+type DomainSaveImageDefineXMLArgs struct {
+	File string
+	Dxml string
+	Flags uint32
+}
+
+// DomainCoreDumpArgs is libvirt's remote_domain_core_dump_args
+type DomainCoreDumpArgs struct {
+	Dom Domain
+	To string
+	Flags DomainCoreDumpFlags
+}
+
+// DomainCoreDumpWithFormatArgs is libvirt's remote_domain_core_dump_with_format_args
+type DomainCoreDumpWithFormatArgs struct {
+	Dom Domain
+	To string
+	Dumpformat uint32
+	Flags DomainCoreDumpFlags
+}
+
+// DomainScreenshotArgs is libvirt's remote_domain_screenshot_args
+type DomainScreenshotArgs struct {
+	Dom Domain
+	Screen uint32
+	Flags uint32
+}
+
+// DomainScreenshotRet is libvirt's remote_domain_screenshot_ret
+type DomainScreenshotRet struct {
+	Mime OptString
+}
+
+// DomainGetXMLDescArgs is libvirt's remote_domain_get_xml_desc_args
+type DomainGetXMLDescArgs struct {
+	Dom Domain
+	Flags DomainXMLFlags
+}
+
+// DomainGetXMLDescRet is libvirt's remote_domain_get_xml_desc_ret
+type DomainGetXMLDescRet struct {
+	XML string
+}
+
+// DomainMigratePrepareArgs is libvirt's remote_domain_migrate_prepare_args
+type DomainMigratePrepareArgs struct {
+	UriIn OptString
+	Flags uint64
+	Dname OptString
+	Resource uint64
+}
+
+// DomainMigratePrepareRet is libvirt's remote_domain_migrate_prepare_ret
+type DomainMigratePrepareRet struct {
+	Cookie []byte
+	UriOut OptString
+}
+
+// DomainMigratePerformArgs is libvirt's remote_domain_migrate_perform_args
+type DomainMigratePerformArgs struct {
+	Dom Domain
+	Cookie []byte
+	Uri string
+	Flags uint64
+	Dname OptString
+	Resource uint64
+}
+
+// DomainMigrateFinishArgs is libvirt's remote_domain_migrate_finish_args
+type DomainMigrateFinishArgs struct {
+	Dname string
+	Cookie []byte
+	Uri string
+	Flags uint64
+}
+
+// DomainMigrateFinishRet is libvirt's remote_domain_migrate_finish_ret
+type DomainMigrateFinishRet struct {
+	Ddom Domain
+}
+
+// DomainMigratePrepare2Args is libvirt's remote_domain_migrate_prepare2_args
+type DomainMigratePrepare2Args struct {
+	UriIn OptString
+	Flags uint64
+	Dname OptString
+	Resource uint64
+	DomXML string
+}
+
+// DomainMigratePrepare2Ret is libvirt's remote_domain_migrate_prepare2_ret
+type DomainMigratePrepare2Ret struct {
+	Cookie []byte
+	UriOut OptString
+}
+
+// DomainMigrateFinish2Args is libvirt's remote_domain_migrate_finish2_args
+type DomainMigrateFinish2Args struct {
+	Dname string
+	Cookie []byte
+	Uri string
+	Flags uint64
+	Retcode int32
+}
+
+// DomainMigrateFinish2Ret is libvirt's remote_domain_migrate_finish2_ret
+type DomainMigrateFinish2Ret struct {
+	Ddom Domain
+}
+
+// ConnectListDefinedDomainsArgs is libvirt's remote_connect_list_defined_domains_args
+type ConnectListDefinedDomainsArgs struct {
+	Maxnames int32
+}
+
+// ConnectListDefinedDomainsRet is libvirt's remote_connect_list_defined_domains_ret
+type ConnectListDefinedDomainsRet struct {
+	Names []string
+}
+
+// ConnectNumOfDefinedDomainsRet is libvirt's remote_connect_num_of_defined_domains_ret
+type ConnectNumOfDefinedDomainsRet struct {
+	Num int32
+}
+
+// DomainCreateArgs is libvirt's remote_domain_create_args
+type DomainCreateArgs struct {
+	Dom Domain
+}
+
+// DomainCreateWithFlagsArgs is libvirt's remote_domain_create_with_flags_args
+type DomainCreateWithFlagsArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainCreateWithFlagsRet is libvirt's remote_domain_create_with_flags_ret
+type DomainCreateWithFlagsRet struct {
+	Dom Domain
+}
+
+// DomainCreateWithFilesArgs is libvirt's remote_domain_create_with_files_args
+type DomainCreateWithFilesArgs struct {
+	Dom Domain
+	Flags DomainCreateFlags
+}
+
+// DomainCreateWithFilesRet is libvirt's remote_domain_create_with_files_ret
+type DomainCreateWithFilesRet struct {
+	Dom Domain
+}
+
+// DomainDefineXMLArgs is libvirt's remote_domain_define_xml_args
+type DomainDefineXMLArgs struct {
+	XML string
+}
+
+// DomainDefineXMLRet is libvirt's remote_domain_define_xml_ret
+type DomainDefineXMLRet struct {
+	Dom Domain
+}
+
+// DomainDefineXMLFlagsArgs is libvirt's remote_domain_define_xml_flags_args
+type DomainDefineXMLFlagsArgs struct {
+	XML string
+	Flags DomainDefineFlags
+}
+
+// DomainDefineXMLFlagsRet is libvirt's remote_domain_define_xml_flags_ret
+type DomainDefineXMLFlagsRet struct {
+	Dom Domain
+}
+
+// DomainUndefineArgs is libvirt's remote_domain_undefine_args
+type DomainUndefineArgs struct {
+	Dom Domain
+}
+
+// DomainUndefineFlagsArgs is libvirt's remote_domain_undefine_flags_args
+type DomainUndefineFlagsArgs struct {
+	Dom Domain
+	Flags DomainUndefineFlagsValues
+}
+
+// DomainInjectNmiArgs is libvirt's remote_domain_inject_nmi_args
+type DomainInjectNmiArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainSendKeyArgs is libvirt's remote_domain_send_key_args
+type DomainSendKeyArgs struct {
+	Dom Domain
+	Codeset uint32
+	Holdtime uint32
+	Keycodes []uint32
+	Flags uint32
+}
+
+// DomainSendProcessSignalArgs is libvirt's remote_domain_send_process_signal_args
+type DomainSendProcessSignalArgs struct {
+	Dom Domain
+	PidValue int64
+	Signum uint32
+	Flags uint32
+}
+
+// DomainSetVcpusArgs is libvirt's remote_domain_set_vcpus_args
+type DomainSetVcpusArgs struct {
+	Dom Domain
+	Nvcpus uint32
+}
+
+// DomainSetVcpusFlagsArgs is libvirt's remote_domain_set_vcpus_flags_args
+type DomainSetVcpusFlagsArgs struct {
+	Dom Domain
+	Nvcpus uint32
+	Flags uint32
+}
+
+// DomainGetVcpusFlagsArgs is libvirt's remote_domain_get_vcpus_flags_args
+type DomainGetVcpusFlagsArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainGetVcpusFlagsRet is libvirt's remote_domain_get_vcpus_flags_ret
+type DomainGetVcpusFlagsRet struct {
+	Num int32
+}
+
+// DomainPinVcpuArgs is libvirt's remote_domain_pin_vcpu_args
+type DomainPinVcpuArgs struct {
+	Dom Domain
+	Vcpu uint32
+	Cpumap []byte
+}
+
+// DomainPinVcpuFlagsArgs is libvirt's remote_domain_pin_vcpu_flags_args
+type DomainPinVcpuFlagsArgs struct {
+	Dom Domain
+	Vcpu uint32
+	Cpumap []byte
+	Flags uint32
+}
+
+// DomainGetVcpuPinInfoArgs is libvirt's remote_domain_get_vcpu_pin_info_args
+type DomainGetVcpuPinInfoArgs struct {
+	Dom Domain
+	Ncpumaps int32
+	Maplen int32
+	Flags uint32
+}
+
+// DomainGetVcpuPinInfoRet is libvirt's remote_domain_get_vcpu_pin_info_ret
+type DomainGetVcpuPinInfoRet struct {
+	Cpumaps []byte
+	Num int32
+}
+
+// DomainPinEmulatorArgs is libvirt's remote_domain_pin_emulator_args
+type DomainPinEmulatorArgs struct {
+	Dom Domain
+	Cpumap []byte
+	Flags DomainModificationImpact
+}
+
+// DomainGetEmulatorPinInfoArgs is libvirt's remote_domain_get_emulator_pin_info_args
+type DomainGetEmulatorPinInfoArgs struct {
+	Dom Domain
+	Maplen int32
+	Flags DomainModificationImpact
+}
+
+// DomainGetEmulatorPinInfoRet is libvirt's remote_domain_get_emulator_pin_info_ret
+type DomainGetEmulatorPinInfoRet struct {
+	Cpumaps []byte
+	Ret int32
+}
+
+// DomainGetVcpusArgs is libvirt's remote_domain_get_vcpus_args
+type DomainGetVcpusArgs struct {
+	Dom Domain
+	Maxinfo int32
+	Maplen int32
+}
+
+// DomainGetVcpusRet is libvirt's remote_domain_get_vcpus_ret
+type DomainGetVcpusRet struct {
+	Info []VcpuInfo
+	Cpumaps []byte
+}
+
+// DomainGetMaxVcpusArgs is libvirt's remote_domain_get_max_vcpus_args
+type DomainGetMaxVcpusArgs struct {
+	Dom Domain
+}
+
+// DomainGetMaxVcpusRet is libvirt's remote_domain_get_max_vcpus_ret
+type DomainGetMaxVcpusRet struct {
+	Num int32
+}
+
+// DomainIothreadInfo is libvirt's remote_domain_iothread_info
+type DomainIothreadInfo struct {
+	IothreadID uint32
+	Cpumap []byte
+}
+
+// DomainGetIothreadInfoArgs is libvirt's remote_domain_get_iothread_info_args
+type DomainGetIothreadInfoArgs struct {
+	Dom Domain
+	Flags DomainModificationImpact
+}
+
+// DomainGetIothreadInfoRet is libvirt's remote_domain_get_iothread_info_ret
+type DomainGetIothreadInfoRet struct {
+	Info []DomainIothreadInfo
+	Ret uint32
+}
+
+// DomainPinIothreadArgs is libvirt's remote_domain_pin_iothread_args
+type DomainPinIothreadArgs struct {
+	Dom Domain
+	IothreadsID uint32
+	Cpumap []byte
+	Flags DomainModificationImpact
+}
+
+// DomainAddIothreadArgs is libvirt's remote_domain_add_iothread_args
+type DomainAddIothreadArgs struct {
+	Dom Domain
+	IothreadID uint32
+	Flags DomainModificationImpact
+}
+
+// DomainDelIothreadArgs is libvirt's remote_domain_del_iothread_args
+type DomainDelIothreadArgs struct {
+	Dom Domain
+	IothreadID uint32
+	Flags DomainModificationImpact
+}
+
+// DomainSetIothreadParamsArgs is libvirt's remote_domain_set_iothread_params_args
+type DomainSetIothreadParamsArgs struct {
+	Dom Domain
+	IothreadID uint32
+	Params []TypedParam
+	Flags uint32
+}
+
+// DomainGetSecurityLabelArgs is libvirt's remote_domain_get_security_label_args
+type DomainGetSecurityLabelArgs struct {
+	Dom Domain
+}
+
+// DomainGetSecurityLabelRet is libvirt's remote_domain_get_security_label_ret
+type DomainGetSecurityLabelRet struct {
+	Label []int8
+	Enforcing int32
+}
+
+// DomainGetSecurityLabelListArgs is libvirt's remote_domain_get_security_label_list_args
+type DomainGetSecurityLabelListArgs struct {
+	Dom Domain
+}
+
+// DomainGetSecurityLabelListRet is libvirt's remote_domain_get_security_label_list_ret
+type DomainGetSecurityLabelListRet struct {
+	Labels []DomainGetSecurityLabelRet
+	Ret int32
+}
+
+// NodeGetSecurityModelRet is libvirt's remote_node_get_security_model_ret
+type NodeGetSecurityModelRet struct {
+	Model []int8
+	Doi []int8
+}
+
+// DomainAttachDeviceArgs is libvirt's remote_domain_attach_device_args
+type DomainAttachDeviceArgs struct {
+	Dom Domain
+	XML string
+}
+
+// DomainAttachDeviceFlagsArgs is libvirt's remote_domain_attach_device_flags_args
+type DomainAttachDeviceFlagsArgs struct {
+	Dom Domain
+	XML string
+	Flags uint32
+}
+
+// DomainDetachDeviceArgs is libvirt's remote_domain_detach_device_args
+type DomainDetachDeviceArgs struct {
+	Dom Domain
+	XML string
+}
+
+// DomainDetachDeviceFlagsArgs is libvirt's remote_domain_detach_device_flags_args
+type DomainDetachDeviceFlagsArgs struct {
+	Dom Domain
+	XML string
+	Flags uint32
+}
+
+// DomainUpdateDeviceFlagsArgs is libvirt's remote_domain_update_device_flags_args
+type DomainUpdateDeviceFlagsArgs struct {
+	Dom Domain
+	XML string
+	Flags DomainDeviceModifyFlags
+}
+
+// DomainDetachDeviceAliasArgs is libvirt's remote_domain_detach_device_alias_args
+type DomainDetachDeviceAliasArgs struct {
+	Dom Domain
+	Alias string
+	Flags uint32
+}
+
+// DomainGetAutostartArgs is libvirt's remote_domain_get_autostart_args
+type DomainGetAutostartArgs struct {
+	Dom Domain
+}
+
+// DomainGetAutostartRet is libvirt's remote_domain_get_autostart_ret
+type DomainGetAutostartRet struct {
+	Autostart int32
+}
+
+// DomainSetAutostartArgs is libvirt's remote_domain_set_autostart_args
+type DomainSetAutostartArgs struct {
+	Dom Domain
+	Autostart int32
+}
+
+// DomainSetMetadataArgs is libvirt's remote_domain_set_metadata_args
+type DomainSetMetadataArgs struct {
+	Dom Domain
+	Type int32
+	Metadata OptString
+	Key OptString
+	Uri OptString
+	Flags DomainModificationImpact
+}
+
+// DomainGetMetadataArgs is libvirt's remote_domain_get_metadata_args
+type DomainGetMetadataArgs struct {
+	Dom Domain
+	Type int32
+	Uri OptString
+	Flags DomainModificationImpact
+}
+
+// DomainGetMetadataRet is libvirt's remote_domain_get_metadata_ret
+type DomainGetMetadataRet struct {
+	Metadata string
+}
+
+// DomainBlockJobAbortArgs is libvirt's remote_domain_block_job_abort_args
+type DomainBlockJobAbortArgs struct {
+	Dom Domain
+	Path string
+	Flags DomainBlockJobAbortFlags
+}
+
+// DomainGetBlockJobInfoArgs is libvirt's remote_domain_get_block_job_info_args
+type DomainGetBlockJobInfoArgs struct {
+	Dom Domain
+	Path string
+	Flags uint32
+}
+
+// DomainGetBlockJobInfoRet is libvirt's remote_domain_get_block_job_info_ret
+type DomainGetBlockJobInfoRet struct {
+	Found int32
+	Type int32
+	Bandwidth uint64
+	Cur uint64
+	End uint64
+}
+
+// DomainBlockJobSetSpeedArgs is libvirt's remote_domain_block_job_set_speed_args
+type DomainBlockJobSetSpeedArgs struct {
+	Dom Domain
+	Path string
+	Bandwidth uint64
+	Flags DomainBlockJobSetSpeedFlags
+}
+
+// DomainBlockPullArgs is libvirt's remote_domain_block_pull_args
+type DomainBlockPullArgs struct {
+	Dom Domain
+	Path string
+	Bandwidth uint64
+	Flags DomainBlockPullFlags
+}
+
+// DomainBlockRebaseArgs is libvirt's remote_domain_block_rebase_args
+type DomainBlockRebaseArgs struct {
+	Dom Domain
+	Path string
+	Base OptString
+	Bandwidth uint64
+	Flags DomainBlockRebaseFlags
+}
+
+// DomainBlockCopyArgs is libvirt's remote_domain_block_copy_args
+type DomainBlockCopyArgs struct {
+	Dom Domain
+	Path string
+	Destxml string
+	Params []TypedParam
+	Flags DomainBlockCopyFlags
+}
+
+// DomainBlockCommitArgs is libvirt's remote_domain_block_commit_args
+type DomainBlockCommitArgs struct {
+	Dom Domain
+	Disk string
+	Base OptString
+	Top OptString
+	Bandwidth uint64
+	Flags DomainBlockCommitFlags
+}
+
+// DomainSetBlockIOTuneArgs is libvirt's remote_domain_set_block_io_tune_args
+type DomainSetBlockIOTuneArgs struct {
+	Dom Domain
+	Disk string
+	Params []TypedParam
+	Flags uint32
+}
+
+// DomainGetBlockIOTuneArgs is libvirt's remote_domain_get_block_io_tune_args
+type DomainGetBlockIOTuneArgs struct {
+	Dom Domain
+	Disk OptString
+	Nparams int32
+	Flags uint32
+}
+
+// DomainGetBlockIOTuneRet is libvirt's remote_domain_get_block_io_tune_ret
+type DomainGetBlockIOTuneRet struct {
+	Params []TypedParam
+	Nparams int32
+}
+
+// DomainGetCPUStatsArgs is libvirt's remote_domain_get_cpu_stats_args
+type DomainGetCPUStatsArgs struct {
+	Dom Domain
+	Nparams uint32
+	StartCPU int32
+	Ncpus uint32
+	Flags TypedParameterFlags
+}
+
+// DomainGetCPUStatsRet is libvirt's remote_domain_get_cpu_stats_ret
+type DomainGetCPUStatsRet struct {
+	Params []TypedParam
+	Nparams int32
+}
+
+// DomainGetHostnameArgs is libvirt's remote_domain_get_hostname_args
+type DomainGetHostnameArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainGetHostnameRet is libvirt's remote_domain_get_hostname_ret
+type DomainGetHostnameRet struct {
+	Hostname string
+}
+
+// ConnectNumOfNetworksRet is libvirt's remote_connect_num_of_networks_ret
+type ConnectNumOfNetworksRet struct {
+	Num int32
+}
+
+// ConnectListNetworksArgs is libvirt's remote_connect_list_networks_args
+type ConnectListNetworksArgs struct {
+	Maxnames int32
+}
+
+// ConnectListNetworksRet is libvirt's remote_connect_list_networks_ret
+type ConnectListNetworksRet struct {
+	Names []string
+}
+
+// ConnectNumOfDefinedNetworksRet is libvirt's remote_connect_num_of_defined_networks_ret
+type ConnectNumOfDefinedNetworksRet struct {
+	Num int32
+}
+
+// ConnectListDefinedNetworksArgs is libvirt's remote_connect_list_defined_networks_args
+type ConnectListDefinedNetworksArgs struct {
+	Maxnames int32
+}
+
+// ConnectListDefinedNetworksRet is libvirt's remote_connect_list_defined_networks_ret
+type ConnectListDefinedNetworksRet struct {
+	Names []string
+}
+
+// NetworkLookupByUUIDArgs is libvirt's remote_network_lookup_by_uuid_args
+type NetworkLookupByUUIDArgs struct {
+	UUID UUID
+}
+
+// NetworkLookupByUUIDRet is libvirt's remote_network_lookup_by_uuid_ret
+type NetworkLookupByUUIDRet struct {
+	Net Network
+}
+
+// NetworkLookupByNameArgs is libvirt's remote_network_lookup_by_name_args
+type NetworkLookupByNameArgs struct {
+	Name string
+}
+
+// NetworkLookupByNameRet is libvirt's remote_network_lookup_by_name_ret
+type NetworkLookupByNameRet struct {
+	Net Network
+}
+
+// NetworkCreateXMLArgs is libvirt's remote_network_create_xml_args
+type NetworkCreateXMLArgs struct {
+	XML string
+}
+
+// NetworkCreateXMLRet is libvirt's remote_network_create_xml_ret
+type NetworkCreateXMLRet struct {
+	Net Network
+}
+
+// NetworkDefineXMLArgs is libvirt's remote_network_define_xml_args
+type NetworkDefineXMLArgs struct {
+	XML string
+}
+
+// NetworkDefineXMLRet is libvirt's remote_network_define_xml_ret
+type NetworkDefineXMLRet struct {
+	Net Network
+}
+
+// NetworkUndefineArgs is libvirt's remote_network_undefine_args
+type NetworkUndefineArgs struct {
+	Net Network
+}
+
+// NetworkUpdateArgs is libvirt's remote_network_update_args
+type NetworkUpdateArgs struct {
+	Net Network
+	Command uint32
+	Section uint32
+	ParentIndex int32
+	XML string
+	Flags NetworkUpdateFlags
+}
+
+// NetworkCreateArgs is libvirt's remote_network_create_args
+type NetworkCreateArgs struct {
+	Net Network
+}
+
+// NetworkDestroyArgs is libvirt's remote_network_destroy_args
+type NetworkDestroyArgs struct {
+	Net Network
+}
+
+// NetworkGetXMLDescArgs is libvirt's remote_network_get_xml_desc_args
+type NetworkGetXMLDescArgs struct {
+	Net Network
+	Flags uint32
+}
+
+// NetworkGetXMLDescRet is libvirt's remote_network_get_xml_desc_ret
+type NetworkGetXMLDescRet struct {
+	XML string
+}
+
+// NetworkGetBridgeNameArgs is libvirt's remote_network_get_bridge_name_args
+type NetworkGetBridgeNameArgs struct {
+	Net Network
+}
+
+// NetworkGetBridgeNameRet is libvirt's remote_network_get_bridge_name_ret
+type NetworkGetBridgeNameRet struct {
+	Name string
+}
+
+// NetworkGetAutostartArgs is libvirt's remote_network_get_autostart_args
+type NetworkGetAutostartArgs struct {
+	Net Network
+}
+
+// NetworkGetAutostartRet is libvirt's remote_network_get_autostart_ret
+type NetworkGetAutostartRet struct {
+	Autostart int32
+}
+
+// NetworkSetAutostartArgs is libvirt's remote_network_set_autostart_args
+type NetworkSetAutostartArgs struct {
+	Net Network
+	Autostart int32
+}
+
+// ConnectNumOfNwfiltersRet is libvirt's remote_connect_num_of_nwfilters_ret
+type ConnectNumOfNwfiltersRet struct {
+	Num int32
+}
+
+// ConnectListNwfiltersArgs is libvirt's remote_connect_list_nwfilters_args
+type ConnectListNwfiltersArgs struct {
+	Maxnames int32
+}
+
+// ConnectListNwfiltersRet is libvirt's remote_connect_list_nwfilters_ret
+type ConnectListNwfiltersRet struct {
+	Names []string
+}
+
+// NwfilterLookupByUUIDArgs is libvirt's remote_nwfilter_lookup_by_uuid_args
+type NwfilterLookupByUUIDArgs struct {
+	UUID UUID
+}
+
+// NwfilterLookupByUUIDRet is libvirt's remote_nwfilter_lookup_by_uuid_ret
+type NwfilterLookupByUUIDRet struct {
+	OptNwfilter Nwfilter
+}
+
+// NwfilterLookupByNameArgs is libvirt's remote_nwfilter_lookup_by_name_args
+type NwfilterLookupByNameArgs struct {
+	Name string
+}
+
+// NwfilterLookupByNameRet is libvirt's remote_nwfilter_lookup_by_name_ret
+type NwfilterLookupByNameRet struct {
+	OptNwfilter Nwfilter
+}
+
+// NwfilterDefineXMLArgs is libvirt's remote_nwfilter_define_xml_args
+type NwfilterDefineXMLArgs struct {
+	XML string
+}
+
+// NwfilterDefineXMLRet is libvirt's remote_nwfilter_define_xml_ret
+type NwfilterDefineXMLRet struct {
+	OptNwfilter Nwfilter
+}
+
+// NwfilterUndefineArgs is libvirt's remote_nwfilter_undefine_args
+type NwfilterUndefineArgs struct {
+	OptNwfilter Nwfilter
+}
+
+// NwfilterGetXMLDescArgs is libvirt's remote_nwfilter_get_xml_desc_args
+type NwfilterGetXMLDescArgs struct {
+	OptNwfilter Nwfilter
+	Flags uint32
+}
+
+// NwfilterGetXMLDescRet is libvirt's remote_nwfilter_get_xml_desc_ret
+type NwfilterGetXMLDescRet struct {
+	XML string
+}
+
+// ConnectNumOfInterfacesRet is libvirt's remote_connect_num_of_interfaces_ret
+type ConnectNumOfInterfacesRet struct {
+	Num int32
+}
+
+// ConnectListInterfacesArgs is libvirt's remote_connect_list_interfaces_args
+type ConnectListInterfacesArgs struct {
+	Maxnames int32
+}
+
+// ConnectListInterfacesRet is libvirt's remote_connect_list_interfaces_ret
+type ConnectListInterfacesRet struct {
+	Names []string
+}
+
+// ConnectNumOfDefinedInterfacesRet is libvirt's remote_connect_num_of_defined_interfaces_ret
+type ConnectNumOfDefinedInterfacesRet struct {
+	Num int32
+}
+
+// ConnectListDefinedInterfacesArgs is libvirt's remote_connect_list_defined_interfaces_args
+type ConnectListDefinedInterfacesArgs struct {
+	Maxnames int32
+}
+
+// ConnectListDefinedInterfacesRet is libvirt's remote_connect_list_defined_interfaces_ret
+type ConnectListDefinedInterfacesRet struct {
+	Names []string
+}
+
+// InterfaceLookupByNameArgs is libvirt's remote_interface_lookup_by_name_args
+type InterfaceLookupByNameArgs struct {
+	Name string
+}
+
+// InterfaceLookupByNameRet is libvirt's remote_interface_lookup_by_name_ret
+type InterfaceLookupByNameRet struct {
+	Iface Interface
+}
+
+// InterfaceLookupByMacStringArgs is libvirt's remote_interface_lookup_by_mac_string_args
+type InterfaceLookupByMacStringArgs struct {
+	Mac string
+}
+
+// InterfaceLookupByMacStringRet is libvirt's remote_interface_lookup_by_mac_string_ret
+type InterfaceLookupByMacStringRet struct {
+	Iface Interface
+}
+
+// InterfaceGetXMLDescArgs is libvirt's remote_interface_get_xml_desc_args
+type InterfaceGetXMLDescArgs struct {
+	Iface Interface
+	Flags uint32
+}
+
+// InterfaceGetXMLDescRet is libvirt's remote_interface_get_xml_desc_ret
+type InterfaceGetXMLDescRet struct {
+	XML string
+}
+
+// InterfaceDefineXMLArgs is libvirt's remote_interface_define_xml_args
+type InterfaceDefineXMLArgs struct {
+	XML string
+	Flags uint32
+}
+
+// InterfaceDefineXMLRet is libvirt's remote_interface_define_xml_ret
+type InterfaceDefineXMLRet struct {
+	Iface Interface
+}
+
+// InterfaceUndefineArgs is libvirt's remote_interface_undefine_args
+type InterfaceUndefineArgs struct {
+	Iface Interface
+}
+
+// InterfaceCreateArgs is libvirt's remote_interface_create_args
+type InterfaceCreateArgs struct {
+	Iface Interface
+	Flags uint32
+}
+
+// InterfaceDestroyArgs is libvirt's remote_interface_destroy_args
+type InterfaceDestroyArgs struct {
+	Iface Interface
+	Flags uint32
+}
+
+// InterfaceChangeBeginArgs is libvirt's remote_interface_change_begin_args
+type InterfaceChangeBeginArgs struct {
+	Flags uint32
+}
+
+// InterfaceChangeCommitArgs is libvirt's remote_interface_change_commit_args
+type InterfaceChangeCommitArgs struct {
+	Flags uint32
+}
+
+// InterfaceChangeRollbackArgs is libvirt's remote_interface_change_rollback_args
+type InterfaceChangeRollbackArgs struct {
+	Flags uint32
+}
+
+// AuthListRet is libvirt's remote_auth_list_ret
+type AuthListRet struct {
+	Types []AuthType
+}
+
+// AuthSaslInitRet is libvirt's remote_auth_sasl_init_ret
+type AuthSaslInitRet struct {
+	Mechlist string
+}
+
+// AuthSaslStartArgs is libvirt's remote_auth_sasl_start_args
+type AuthSaslStartArgs struct {
+	Mech string
+	Nil int32
+	Data []int8
+}
+
+// AuthSaslStartRet is libvirt's remote_auth_sasl_start_ret
+type AuthSaslStartRet struct {
+	Complete int32
+	Nil int32
+	Data []int8
+}
+
+// AuthSaslStepArgs is libvirt's remote_auth_sasl_step_args
+type AuthSaslStepArgs struct {
+	Nil int32
+	Data []int8
+}
+
+// AuthSaslStepRet is libvirt's remote_auth_sasl_step_ret
+type AuthSaslStepRet struct {
+	Complete int32
+	Nil int32
+	Data []int8
+}
+
+// AuthPolkitRet is libvirt's remote_auth_polkit_ret
+type AuthPolkitRet struct {
+	Complete int32
+}
+
+// ConnectNumOfStoragePoolsRet is libvirt's remote_connect_num_of_storage_pools_ret
+type ConnectNumOfStoragePoolsRet struct {
+	Num int32
+}
+
+// ConnectListStoragePoolsArgs is libvirt's remote_connect_list_storage_pools_args
+type ConnectListStoragePoolsArgs struct {
+	Maxnames int32
+}
+
+// ConnectListStoragePoolsRet is libvirt's remote_connect_list_storage_pools_ret
+type ConnectListStoragePoolsRet struct {
+	Names []string
+}
+
+// ConnectNumOfDefinedStoragePoolsRet is libvirt's remote_connect_num_of_defined_storage_pools_ret
+type ConnectNumOfDefinedStoragePoolsRet struct {
+	Num int32
+}
+
+// ConnectListDefinedStoragePoolsArgs is libvirt's remote_connect_list_defined_storage_pools_args
+type ConnectListDefinedStoragePoolsArgs struct {
+	Maxnames int32
+}
+
+// ConnectListDefinedStoragePoolsRet is libvirt's remote_connect_list_defined_storage_pools_ret
+type ConnectListDefinedStoragePoolsRet struct {
+	Names []string
+}
+
+// ConnectFindStoragePoolSourcesArgs is libvirt's remote_connect_find_storage_pool_sources_args
+type ConnectFindStoragePoolSourcesArgs struct {
+	Type string
+	SrcSpec OptString
+	Flags uint32
+}
+
+// ConnectFindStoragePoolSourcesRet is libvirt's remote_connect_find_storage_pool_sources_ret
+type ConnectFindStoragePoolSourcesRet struct {
+	XML string
+}
+
+// StoragePoolLookupByUUIDArgs is libvirt's remote_storage_pool_lookup_by_uuid_args
+type StoragePoolLookupByUUIDArgs struct {
+	UUID UUID
+}
+
+// StoragePoolLookupByUUIDRet is libvirt's remote_storage_pool_lookup_by_uuid_ret
+type StoragePoolLookupByUUIDRet struct {
+	Pool StoragePool
+}
+
+// StoragePoolLookupByNameArgs is libvirt's remote_storage_pool_lookup_by_name_args
+type StoragePoolLookupByNameArgs struct {
+	Name string
+}
+
+// StoragePoolLookupByNameRet is libvirt's remote_storage_pool_lookup_by_name_ret
+type StoragePoolLookupByNameRet struct {
+	Pool StoragePool
+}
+
+// StoragePoolLookupByVolumeArgs is libvirt's remote_storage_pool_lookup_by_volume_args
+type StoragePoolLookupByVolumeArgs struct {
+	Vol StorageVol
+}
+
+// StoragePoolLookupByVolumeRet is libvirt's remote_storage_pool_lookup_by_volume_ret
+type StoragePoolLookupByVolumeRet struct {
+	Pool StoragePool
+}
+
+// StoragePoolLookupByTargetPathArgs is libvirt's remote_storage_pool_lookup_by_target_path_args
+type StoragePoolLookupByTargetPathArgs struct {
+	Path string
+}
+
+// StoragePoolLookupByTargetPathRet is libvirt's remote_storage_pool_lookup_by_target_path_ret
+type StoragePoolLookupByTargetPathRet struct {
+	Pool StoragePool
+}
+
+// StoragePoolCreateXMLArgs is libvirt's remote_storage_pool_create_xml_args
+type StoragePoolCreateXMLArgs struct {
+	XML string
+	Flags StoragePoolCreateFlags
+}
+
+// StoragePoolCreateXMLRet is libvirt's remote_storage_pool_create_xml_ret
+type StoragePoolCreateXMLRet struct {
+	Pool StoragePool
+}
+
+// StoragePoolDefineXMLArgs is libvirt's remote_storage_pool_define_xml_args
+type StoragePoolDefineXMLArgs struct {
+	XML string
+	Flags uint32
+}
+
+// StoragePoolDefineXMLRet is libvirt's remote_storage_pool_define_xml_ret
+type StoragePoolDefineXMLRet struct {
+	Pool StoragePool
+}
+
+// StoragePoolBuildArgs is libvirt's remote_storage_pool_build_args
+type StoragePoolBuildArgs struct {
+	Pool StoragePool
+	Flags StoragePoolBuildFlags
+}
+
+// StoragePoolUndefineArgs is libvirt's remote_storage_pool_undefine_args
+type StoragePoolUndefineArgs struct {
+	Pool StoragePool
+}
+
+// StoragePoolCreateArgs is libvirt's remote_storage_pool_create_args
+type StoragePoolCreateArgs struct {
+	Pool StoragePool
+	Flags StoragePoolCreateFlags
+}
+
+// StoragePoolDestroyArgs is libvirt's remote_storage_pool_destroy_args
+type StoragePoolDestroyArgs struct {
+	Pool StoragePool
+}
+
+// StoragePoolDeleteArgs is libvirt's remote_storage_pool_delete_args
+type StoragePoolDeleteArgs struct {
+	Pool StoragePool
+	Flags StoragePoolDeleteFlags
+}
+
+// StoragePoolRefreshArgs is libvirt's remote_storage_pool_refresh_args
+type StoragePoolRefreshArgs struct {
+	Pool StoragePool
+	Flags uint32
+}
+
+// StoragePoolGetXMLDescArgs is libvirt's remote_storage_pool_get_xml_desc_args
+type StoragePoolGetXMLDescArgs struct {
+	Pool StoragePool
+	Flags StorageXMLFlags
+}
+
+// StoragePoolGetXMLDescRet is libvirt's remote_storage_pool_get_xml_desc_ret
+type StoragePoolGetXMLDescRet struct {
+	XML string
+}
+
+// StoragePoolGetInfoArgs is libvirt's remote_storage_pool_get_info_args
+type StoragePoolGetInfoArgs struct {
+	Pool StoragePool
+}
+
+// StoragePoolGetInfoRet is libvirt's remote_storage_pool_get_info_ret
+type StoragePoolGetInfoRet struct {
+	State uint8
+	Capacity uint64
+	Allocation uint64
+	Available uint64
+}
+
+// StoragePoolGetAutostartArgs is libvirt's remote_storage_pool_get_autostart_args
+type StoragePoolGetAutostartArgs struct {
+	Pool StoragePool
+}
+
+// StoragePoolGetAutostartRet is libvirt's remote_storage_pool_get_autostart_ret
+type StoragePoolGetAutostartRet struct {
+	Autostart int32
+}
+
+// StoragePoolSetAutostartArgs is libvirt's remote_storage_pool_set_autostart_args
+type StoragePoolSetAutostartArgs struct {
+	Pool StoragePool
+	Autostart int32
+}
+
+// StoragePoolNumOfVolumesArgs is libvirt's remote_storage_pool_num_of_volumes_args
+type StoragePoolNumOfVolumesArgs struct {
+	Pool StoragePool
+}
+
+// StoragePoolNumOfVolumesRet is libvirt's remote_storage_pool_num_of_volumes_ret
+type StoragePoolNumOfVolumesRet struct {
+	Num int32
+}
+
+// StoragePoolListVolumesArgs is libvirt's remote_storage_pool_list_volumes_args
+type StoragePoolListVolumesArgs struct {
+	Pool StoragePool
+	Maxnames int32
+}
+
+// StoragePoolListVolumesRet is libvirt's remote_storage_pool_list_volumes_ret
+type StoragePoolListVolumesRet struct {
+	Names []string
+}
+
+// StorageVolLookupByNameArgs is libvirt's remote_storage_vol_lookup_by_name_args
+type StorageVolLookupByNameArgs struct {
+	Pool StoragePool
+	Name string
+}
+
+// StorageVolLookupByNameRet is libvirt's remote_storage_vol_lookup_by_name_ret
+type StorageVolLookupByNameRet struct {
+	Vol StorageVol
+}
+
+// StorageVolLookupByKeyArgs is libvirt's remote_storage_vol_lookup_by_key_args
+type StorageVolLookupByKeyArgs struct {
+	Key string
+}
+
+// StorageVolLookupByKeyRet is libvirt's remote_storage_vol_lookup_by_key_ret
+type StorageVolLookupByKeyRet struct {
+	Vol StorageVol
+}
+
+// StorageVolLookupByPathArgs is libvirt's remote_storage_vol_lookup_by_path_args
+type StorageVolLookupByPathArgs struct {
+	Path string
+}
+
+// StorageVolLookupByPathRet is libvirt's remote_storage_vol_lookup_by_path_ret
+type StorageVolLookupByPathRet struct {
+	Vol StorageVol
+}
+
+// StorageVolCreateXMLArgs is libvirt's remote_storage_vol_create_xml_args
+type StorageVolCreateXMLArgs struct {
+	Pool StoragePool
+	XML string
+	Flags StorageVolCreateFlags
+}
+
+// StorageVolCreateXMLRet is libvirt's remote_storage_vol_create_xml_ret
+type StorageVolCreateXMLRet struct {
+	Vol StorageVol
+}
+
+// StorageVolCreateXMLFromArgs is libvirt's remote_storage_vol_create_xml_from_args
+type StorageVolCreateXMLFromArgs struct {
+	Pool StoragePool
+	XML string
+	Clonevol StorageVol
+	Flags StorageVolCreateFlags
+}
+
+// StorageVolCreateXMLFromRet is libvirt's remote_storage_vol_create_xml_from_ret
+type StorageVolCreateXMLFromRet struct {
+	Vol StorageVol
+}
+
+// StorageVolDeleteArgs is libvirt's remote_storage_vol_delete_args
+type StorageVolDeleteArgs struct {
+	Vol StorageVol
+	Flags StorageVolDeleteFlags
+}
+
+// StorageVolWipeArgs is libvirt's remote_storage_vol_wipe_args
+type StorageVolWipeArgs struct {
+	Vol StorageVol
+	Flags uint32
+}
+
+// StorageVolWipePatternArgs is libvirt's remote_storage_vol_wipe_pattern_args
+type StorageVolWipePatternArgs struct {
+	Vol StorageVol
+	Algorithm uint32
+	Flags uint32
+}
+
+// StorageVolGetXMLDescArgs is libvirt's remote_storage_vol_get_xml_desc_args
+type StorageVolGetXMLDescArgs struct {
+	Vol StorageVol
+	Flags uint32
+}
+
+// StorageVolGetXMLDescRet is libvirt's remote_storage_vol_get_xml_desc_ret
+type StorageVolGetXMLDescRet struct {
+	XML string
+}
+
+// StorageVolGetInfoArgs is libvirt's remote_storage_vol_get_info_args
+type StorageVolGetInfoArgs struct {
+	Vol StorageVol
+}
+
+// StorageVolGetInfoRet is libvirt's remote_storage_vol_get_info_ret
+type StorageVolGetInfoRet struct {
+	Type int8
+	Capacity uint64
+	Allocation uint64
+}
+
+// StorageVolGetInfoFlagsArgs is libvirt's remote_storage_vol_get_info_flags_args
+type StorageVolGetInfoFlagsArgs struct {
+	Vol StorageVol
+	Flags uint32
+}
+
+// StorageVolGetInfoFlagsRet is libvirt's remote_storage_vol_get_info_flags_ret
+type StorageVolGetInfoFlagsRet struct {
+	Type int8
+	Capacity uint64
+	Allocation uint64
+}
+
+// StorageVolGetPathArgs is libvirt's remote_storage_vol_get_path_args
+type StorageVolGetPathArgs struct {
+	Vol StorageVol
+}
+
+// StorageVolGetPathRet is libvirt's remote_storage_vol_get_path_ret
+type StorageVolGetPathRet struct {
+	Name string
+}
+
+// StorageVolResizeArgs is libvirt's remote_storage_vol_resize_args
+type StorageVolResizeArgs struct {
+	Vol StorageVol
+	Capacity uint64
+	Flags StorageVolResizeFlags
+}
+
+// NodeNumOfDevicesArgs is libvirt's remote_node_num_of_devices_args
+type NodeNumOfDevicesArgs struct {
+	Cap OptString
+	Flags uint32
+}
+
+// NodeNumOfDevicesRet is libvirt's remote_node_num_of_devices_ret
+type NodeNumOfDevicesRet struct {
+	Num int32
+}
+
+// NodeListDevicesArgs is libvirt's remote_node_list_devices_args
+type NodeListDevicesArgs struct {
+	Cap OptString
+	Maxnames int32
+	Flags uint32
+}
+
+// NodeListDevicesRet is libvirt's remote_node_list_devices_ret
+type NodeListDevicesRet struct {
+	Names []string
+}
+
+// NodeDeviceLookupByNameArgs is libvirt's remote_node_device_lookup_by_name_args
+type NodeDeviceLookupByNameArgs struct {
+	Name string
+}
+
+// NodeDeviceLookupByNameRet is libvirt's remote_node_device_lookup_by_name_ret
+type NodeDeviceLookupByNameRet struct {
+	Dev NodeDevice
+}
+
+// NodeDeviceLookupScsiHostByWwnArgs is libvirt's remote_node_device_lookup_scsi_host_by_wwn_args
+type NodeDeviceLookupScsiHostByWwnArgs struct {
+	Wwnn string
+	Wwpn string
+	Flags uint32
+}
+
+// NodeDeviceLookupScsiHostByWwnRet is libvirt's remote_node_device_lookup_scsi_host_by_wwn_ret
+type NodeDeviceLookupScsiHostByWwnRet struct {
+	Dev NodeDevice
+}
+
+// NodeDeviceGetXMLDescArgs is libvirt's remote_node_device_get_xml_desc_args
+type NodeDeviceGetXMLDescArgs struct {
+	Name string
+	Flags uint32
+}
+
+// NodeDeviceGetXMLDescRet is libvirt's remote_node_device_get_xml_desc_ret
+type NodeDeviceGetXMLDescRet struct {
+	XML string
+}
+
+// NodeDeviceGetParentArgs is libvirt's remote_node_device_get_parent_args
+type NodeDeviceGetParentArgs struct {
+	Name string
+}
+
+// NodeDeviceGetParentRet is libvirt's remote_node_device_get_parent_ret
+type NodeDeviceGetParentRet struct {
+	ParentName OptString
+}
+
+// NodeDeviceNumOfCapsArgs is libvirt's remote_node_device_num_of_caps_args
+type NodeDeviceNumOfCapsArgs struct {
+	Name string
+}
+
+// NodeDeviceNumOfCapsRet is libvirt's remote_node_device_num_of_caps_ret
+type NodeDeviceNumOfCapsRet struct {
+	Num int32
+}
+
+// NodeDeviceListCapsArgs is libvirt's remote_node_device_list_caps_args
+type NodeDeviceListCapsArgs struct {
+	Name string
+	Maxnames int32
+}
+
+// NodeDeviceListCapsRet is libvirt's remote_node_device_list_caps_ret
+type NodeDeviceListCapsRet struct {
+	Names []string
+}
+
+// NodeDeviceDettachArgs is libvirt's remote_node_device_dettach_args
+type NodeDeviceDettachArgs struct {
+	Name string
+}
+
+// NodeDeviceDetachFlagsArgs is libvirt's remote_node_device_detach_flags_args
+type NodeDeviceDetachFlagsArgs struct {
+	Name string
+	DriverName OptString
+	Flags uint32
+}
+
+// NodeDeviceReAttachArgs is libvirt's remote_node_device_re_attach_args
+type NodeDeviceReAttachArgs struct {
+	Name string
+}
+
+// NodeDeviceResetArgs is libvirt's remote_node_device_reset_args
+type NodeDeviceResetArgs struct {
+	Name string
+}
+
+// NodeDeviceCreateXMLArgs is libvirt's remote_node_device_create_xml_args
+type NodeDeviceCreateXMLArgs struct {
+	XMLDesc string
+	Flags uint32
+}
+
+// NodeDeviceCreateXMLRet is libvirt's remote_node_device_create_xml_ret
+type NodeDeviceCreateXMLRet struct {
+	Dev NodeDevice
+}
+
+// NodeDeviceDestroyArgs is libvirt's remote_node_device_destroy_args
+type NodeDeviceDestroyArgs struct {
+	Name string
+}
+
+// ConnectDomainEventRegisterRet is libvirt's remote_connect_domain_event_register_ret
+type ConnectDomainEventRegisterRet struct {
+	CbRegistered int32
+}
+
+// ConnectDomainEventDeregisterRet is libvirt's remote_connect_domain_event_deregister_ret
+type ConnectDomainEventDeregisterRet struct {
+	CbRegistered int32
+}
+
+// DomainEventLifecycleMsg is libvirt's remote_domain_event_lifecycle_msg
+type DomainEventLifecycleMsg struct {
+	Dom Domain
+	Event int32
+	Detail int32
+}
+
+// DomainEventCallbackLifecycleMsg is libvirt's remote_domain_event_callback_lifecycle_msg
+type DomainEventCallbackLifecycleMsg struct {
+	CallbackID int32
+	Msg DomainEventLifecycleMsg
+}
+
+// ConnectDomainXMLFromNativeArgs is libvirt's remote_connect_domain_xml_from_native_args
+type ConnectDomainXMLFromNativeArgs struct {
+	NativeFormat string
+	NativeConfig string
+	Flags uint32
+}
+
+// ConnectDomainXMLFromNativeRet is libvirt's remote_connect_domain_xml_from_native_ret
+type ConnectDomainXMLFromNativeRet struct {
+	DomainXML string
+}
+
+// ConnectDomainXMLToNativeArgs is libvirt's remote_connect_domain_xml_to_native_args
+type ConnectDomainXMLToNativeArgs struct {
+	NativeFormat string
+	DomainXML string
+	Flags uint32
+}
+
+// ConnectDomainXMLToNativeRet is libvirt's remote_connect_domain_xml_to_native_ret
+type ConnectDomainXMLToNativeRet struct {
+	NativeConfig string
+}
+
+// ConnectNumOfSecretsRet is libvirt's remote_connect_num_of_secrets_ret
+type ConnectNumOfSecretsRet struct {
+	Num int32
+}
+
+// ConnectListSecretsArgs is libvirt's remote_connect_list_secrets_args
+type ConnectListSecretsArgs struct {
+	Maxuuids int32
+}
+
+// ConnectListSecretsRet is libvirt's remote_connect_list_secrets_ret
+type ConnectListSecretsRet struct {
+	Uuids []string
+}
+
+// SecretLookupByUUIDArgs is libvirt's remote_secret_lookup_by_uuid_args
+type SecretLookupByUUIDArgs struct {
+	UUID UUID
+}
+
+// SecretLookupByUUIDRet is libvirt's remote_secret_lookup_by_uuid_ret
+type SecretLookupByUUIDRet struct {
+	OptSecret Secret
+}
+
+// SecretDefineXMLArgs is libvirt's remote_secret_define_xml_args
+type SecretDefineXMLArgs struct {
+	XML string
+	Flags uint32
+}
+
+// SecretDefineXMLRet is libvirt's remote_secret_define_xml_ret
+type SecretDefineXMLRet struct {
+	OptSecret Secret
+}
+
+// SecretGetXMLDescArgs is libvirt's remote_secret_get_xml_desc_args
+type SecretGetXMLDescArgs struct {
+	OptSecret Secret
+	Flags uint32
+}
+
+// SecretGetXMLDescRet is libvirt's remote_secret_get_xml_desc_ret
+type SecretGetXMLDescRet struct {
+	XML string
+}
+
+// SecretSetValueArgs is libvirt's remote_secret_set_value_args
+type SecretSetValueArgs struct {
+	OptSecret Secret
+	Value []byte
+	Flags uint32
+}
+
+// SecretGetValueArgs is libvirt's remote_secret_get_value_args
+type SecretGetValueArgs struct {
+	OptSecret Secret
+	Flags uint32
+}
+
+// SecretGetValueRet is libvirt's remote_secret_get_value_ret
+type SecretGetValueRet struct {
+	Value []byte
+}
+
+// SecretUndefineArgs is libvirt's remote_secret_undefine_args
+type SecretUndefineArgs struct {
+	OptSecret Secret
+}
+
+// SecretLookupByUsageArgs is libvirt's remote_secret_lookup_by_usage_args
+type SecretLookupByUsageArgs struct {
+	UsageType int32
+	UsageID string
+}
+
+// SecretLookupByUsageRet is libvirt's remote_secret_lookup_by_usage_ret
+type SecretLookupByUsageRet struct {
+	OptSecret Secret
+}
+
+// DomainMigratePrepareTunnelArgs is libvirt's remote_domain_migrate_prepare_tunnel_args
+type DomainMigratePrepareTunnelArgs struct {
+	Flags uint64
+	Dname OptString
+	Resource uint64
+	DomXML string
+}
+
+// ConnectIsSecureRet is libvirt's remote_connect_is_secure_ret
+type ConnectIsSecureRet struct {
+	Secure int32
+}
+
+// DomainIsActiveArgs is libvirt's remote_domain_is_active_args
+type DomainIsActiveArgs struct {
+	Dom Domain
+}
+
+// DomainIsActiveRet is libvirt's remote_domain_is_active_ret
+type DomainIsActiveRet struct {
+	Active int32
+}
+
+// DomainIsPersistentArgs is libvirt's remote_domain_is_persistent_args
+type DomainIsPersistentArgs struct {
+	Dom Domain
+}
+
+// DomainIsPersistentRet is libvirt's remote_domain_is_persistent_ret
+type DomainIsPersistentRet struct {
+	Persistent int32
+}
+
+// DomainIsUpdatedArgs is libvirt's remote_domain_is_updated_args
+type DomainIsUpdatedArgs struct {
+	Dom Domain
+}
+
+// DomainIsUpdatedRet is libvirt's remote_domain_is_updated_ret
+type DomainIsUpdatedRet struct {
+	Updated int32
+}
+
+// NetworkIsActiveArgs is libvirt's remote_network_is_active_args
+type NetworkIsActiveArgs struct {
+	Net Network
+}
+
+// NetworkIsActiveRet is libvirt's remote_network_is_active_ret
+type NetworkIsActiveRet struct {
+	Active int32
+}
+
+// NetworkIsPersistentArgs is libvirt's remote_network_is_persistent_args
+type NetworkIsPersistentArgs struct {
+	Net Network
+}
+
+// NetworkIsPersistentRet is libvirt's remote_network_is_persistent_ret
+type NetworkIsPersistentRet struct {
+	Persistent int32
+}
+
+// StoragePoolIsActiveArgs is libvirt's remote_storage_pool_is_active_args
+type StoragePoolIsActiveArgs struct {
+	Pool StoragePool
+}
+
+// StoragePoolIsActiveRet is libvirt's remote_storage_pool_is_active_ret
+type StoragePoolIsActiveRet struct {
+	Active int32
+}
+
+// StoragePoolIsPersistentArgs is libvirt's remote_storage_pool_is_persistent_args
+type StoragePoolIsPersistentArgs struct {
+	Pool StoragePool
+}
+
+// StoragePoolIsPersistentRet is libvirt's remote_storage_pool_is_persistent_ret
+type StoragePoolIsPersistentRet struct {
+	Persistent int32
+}
+
+// InterfaceIsActiveArgs is libvirt's remote_interface_is_active_args
+type InterfaceIsActiveArgs struct {
+	Iface Interface
+}
+
+// InterfaceIsActiveRet is libvirt's remote_interface_is_active_ret
+type InterfaceIsActiveRet struct {
+	Active int32
+}
+
+// ConnectCompareCPUArgs is libvirt's remote_connect_compare_cpu_args
+type ConnectCompareCPUArgs struct {
+	XML string
+	Flags ConnectCompareCPUFlags
+}
+
+// ConnectCompareCPURet is libvirt's remote_connect_compare_cpu_ret
+type ConnectCompareCPURet struct {
+	Result int32
+}
+
+// ConnectBaselineCPUArgs is libvirt's remote_connect_baseline_cpu_args
+type ConnectBaselineCPUArgs struct {
+	XMLCPUs []string
+	Flags ConnectBaselineCPUFlags
+}
+
+// ConnectBaselineCPURet is libvirt's remote_connect_baseline_cpu_ret
+type ConnectBaselineCPURet struct {
+	CPU string
+}
+
+// DomainGetJobInfoArgs is libvirt's remote_domain_get_job_info_args
+type DomainGetJobInfoArgs struct {
+	Dom Domain
+}
+
+// DomainGetJobInfoRet is libvirt's remote_domain_get_job_info_ret
+type DomainGetJobInfoRet struct {
+	Type int32
+	TimeElapsed uint64
+	TimeRemaining uint64
+	DataTotal uint64
+	DataProcessed uint64
+	DataRemaining uint64
+	MemTotal uint64
+	MemProcessed uint64
+	MemRemaining uint64
+	FileTotal uint64
+	FileProcessed uint64
+	FileRemaining uint64
+}
+
+// DomainGetJobStatsArgs is libvirt's remote_domain_get_job_stats_args
+type DomainGetJobStatsArgs struct {
+	Dom Domain
+	Flags DomainGetJobStatsFlags
+}
+
+// DomainGetJobStatsRet is libvirt's remote_domain_get_job_stats_ret
+type DomainGetJobStatsRet struct {
+	Type int32
+	Params []TypedParam
+}
+
+// DomainAbortJobArgs is libvirt's remote_domain_abort_job_args
+type DomainAbortJobArgs struct {
+	Dom Domain
+}
+
+// DomainMigrateGetMaxDowntimeArgs is libvirt's remote_domain_migrate_get_max_downtime_args
+type DomainMigrateGetMaxDowntimeArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainMigrateGetMaxDowntimeRet is libvirt's remote_domain_migrate_get_max_downtime_ret
+type DomainMigrateGetMaxDowntimeRet struct {
+	Downtime uint64
+}
+
+// DomainMigrateSetMaxDowntimeArgs is libvirt's remote_domain_migrate_set_max_downtime_args
+type DomainMigrateSetMaxDowntimeArgs struct {
+	Dom Domain
+	Downtime uint64
+	Flags uint32
+}
+
+// DomainMigrateGetCompressionCacheArgs is libvirt's remote_domain_migrate_get_compression_cache_args
+type DomainMigrateGetCompressionCacheArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainMigrateGetCompressionCacheRet is libvirt's remote_domain_migrate_get_compression_cache_ret
+type DomainMigrateGetCompressionCacheRet struct {
+	CacheSize uint64
+}
+
+// DomainMigrateSetCompressionCacheArgs is libvirt's remote_domain_migrate_set_compression_cache_args
+type DomainMigrateSetCompressionCacheArgs struct {
+	Dom Domain
+	CacheSize uint64
+	Flags uint32
+}
+
+// DomainMigrateSetMaxSpeedArgs is libvirt's remote_domain_migrate_set_max_speed_args
+type DomainMigrateSetMaxSpeedArgs struct {
+	Dom Domain
+	Bandwidth uint64
+	Flags uint32
+}
+
+// DomainMigrateGetMaxSpeedArgs is libvirt's remote_domain_migrate_get_max_speed_args
+type DomainMigrateGetMaxSpeedArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainMigrateGetMaxSpeedRet is libvirt's remote_domain_migrate_get_max_speed_ret
+type DomainMigrateGetMaxSpeedRet struct {
+	Bandwidth uint64
+}
+
+// ConnectDomainEventRegisterAnyArgs is libvirt's remote_connect_domain_event_register_any_args
+type ConnectDomainEventRegisterAnyArgs struct {
+	EventID int32
+}
+
+// ConnectDomainEventDeregisterAnyArgs is libvirt's remote_connect_domain_event_deregister_any_args
+type ConnectDomainEventDeregisterAnyArgs struct {
+	EventID int32
+}
+
+// ConnectDomainEventCallbackRegisterAnyArgs is libvirt's remote_connect_domain_event_callback_register_any_args
+type ConnectDomainEventCallbackRegisterAnyArgs struct {
+	EventID int32
+	Dom OptDomain
+}
+
+// ConnectDomainEventCallbackRegisterAnyRet is libvirt's remote_connect_domain_event_callback_register_any_ret
+type ConnectDomainEventCallbackRegisterAnyRet struct {
+	CallbackID int32
+}
+
+// ConnectDomainEventCallbackDeregisterAnyArgs is libvirt's remote_connect_domain_event_callback_deregister_any_args
+type ConnectDomainEventCallbackDeregisterAnyArgs struct {
+	CallbackID int32
+}
+
+// DomainEventRebootMsg is libvirt's remote_domain_event_reboot_msg
+type DomainEventRebootMsg struct {
+	Dom Domain
+}
+
+// DomainEventCallbackRebootMsg is libvirt's remote_domain_event_callback_reboot_msg
+type DomainEventCallbackRebootMsg struct {
+	CallbackID int32
+	Msg DomainEventRebootMsg
+}
+
+// DomainEventRtcChangeMsg is libvirt's remote_domain_event_rtc_change_msg
+type DomainEventRtcChangeMsg struct {
+	Dom Domain
+	Offset int64
+}
+
+// DomainEventCallbackRtcChangeMsg is libvirt's remote_domain_event_callback_rtc_change_msg
+type DomainEventCallbackRtcChangeMsg struct {
+	CallbackID int32
+	Msg DomainEventRtcChangeMsg
+}
+
+// DomainEventWatchdogMsg is libvirt's remote_domain_event_watchdog_msg
+type DomainEventWatchdogMsg struct {
+	Dom Domain
+	Action int32
+}
+
+// DomainEventCallbackWatchdogMsg is libvirt's remote_domain_event_callback_watchdog_msg
+type DomainEventCallbackWatchdogMsg struct {
+	CallbackID int32
+	Msg DomainEventWatchdogMsg
+}
+
+// DomainEventIOErrorMsg is libvirt's remote_domain_event_io_error_msg
+type DomainEventIOErrorMsg struct {
+	Dom Domain
+	SrcPath string
+	DevAlias string
+	Action int32
+}
+
+// DomainEventCallbackIOErrorMsg is libvirt's remote_domain_event_callback_io_error_msg
+type DomainEventCallbackIOErrorMsg struct {
+	CallbackID int32
+	Msg DomainEventIOErrorMsg
+}
+
+// DomainEventIOErrorReasonMsg is libvirt's remote_domain_event_io_error_reason_msg
+type DomainEventIOErrorReasonMsg struct {
+	Dom Domain
+	SrcPath string
+	DevAlias string
+	Action int32
+	Reason string
+}
+
+// DomainEventCallbackIOErrorReasonMsg is libvirt's remote_domain_event_callback_io_error_reason_msg
+type DomainEventCallbackIOErrorReasonMsg struct {
+	CallbackID int32
+	Msg DomainEventIOErrorReasonMsg
+}
+
+// DomainEventGraphicsAddress is libvirt's remote_domain_event_graphics_address
+type DomainEventGraphicsAddress struct {
+	Family int32
+	Node string
+	Service string
+}
+
+// DomainEventGraphicsIdentity is libvirt's remote_domain_event_graphics_identity
+type DomainEventGraphicsIdentity struct {
+	Type string
+	Name string
+}
+
+// DomainEventGraphicsMsg is libvirt's remote_domain_event_graphics_msg
+type DomainEventGraphicsMsg struct {
+	Dom Domain
+	Phase int32
+	Local DomainEventGraphicsAddress
+	Remote DomainEventGraphicsAddress
+	AuthScheme string
+	Subject []DomainEventGraphicsIdentity
+}
+
+// DomainEventCallbackGraphicsMsg is libvirt's remote_domain_event_callback_graphics_msg
+type DomainEventCallbackGraphicsMsg struct {
+	CallbackID int32
+	Msg DomainEventGraphicsMsg
+}
+
+// DomainEventBlockJobMsg is libvirt's remote_domain_event_block_job_msg
+type DomainEventBlockJobMsg struct {
+	Dom Domain
+	Path string
+	Type int32
+	Status int32
+}
+
+// DomainEventCallbackBlockJobMsg is libvirt's remote_domain_event_callback_block_job_msg
+type DomainEventCallbackBlockJobMsg struct {
+	CallbackID int32
+	Msg DomainEventBlockJobMsg
+}
+
+// DomainEventDiskChangeMsg is libvirt's remote_domain_event_disk_change_msg
+type DomainEventDiskChangeMsg struct {
+	Dom Domain
+	OldSrcPath OptString
+	NewSrcPath OptString
+	DevAlias string
+	Reason int32
+}
+
+// DomainEventCallbackDiskChangeMsg is libvirt's remote_domain_event_callback_disk_change_msg
+type DomainEventCallbackDiskChangeMsg struct {
+	CallbackID int32
+	Msg DomainEventDiskChangeMsg
+}
+
+// DomainEventTrayChangeMsg is libvirt's remote_domain_event_tray_change_msg
+type DomainEventTrayChangeMsg struct {
+	Dom Domain
+	DevAlias string
+	Reason int32
+}
+
+// DomainEventCallbackTrayChangeMsg is libvirt's remote_domain_event_callback_tray_change_msg
+type DomainEventCallbackTrayChangeMsg struct {
+	CallbackID int32
+	Msg DomainEventTrayChangeMsg
+}
+
+// DomainEventPmwakeupMsg is libvirt's remote_domain_event_pmwakeup_msg
+type DomainEventPmwakeupMsg struct {
+	Dom Domain
+}
+
+// DomainEventCallbackPmwakeupMsg is libvirt's remote_domain_event_callback_pmwakeup_msg
+type DomainEventCallbackPmwakeupMsg struct {
+	CallbackID int32
+	Reason int32
+	Msg DomainEventPmwakeupMsg
+}
+
+// DomainEventPmsuspendMsg is libvirt's remote_domain_event_pmsuspend_msg
+type DomainEventPmsuspendMsg struct {
+	Dom Domain
+}
+
+// DomainEventCallbackPmsuspendMsg is libvirt's remote_domain_event_callback_pmsuspend_msg
+type DomainEventCallbackPmsuspendMsg struct {
+	CallbackID int32
+	Reason int32
+	Msg DomainEventPmsuspendMsg
+}
+
+// DomainEventBalloonChangeMsg is libvirt's remote_domain_event_balloon_change_msg
+type DomainEventBalloonChangeMsg struct {
+	Dom Domain
+	Actual uint64
+}
+
+// DomainEventCallbackBalloonChangeMsg is libvirt's remote_domain_event_callback_balloon_change_msg
+type DomainEventCallbackBalloonChangeMsg struct {
+	CallbackID int32
+	Msg DomainEventBalloonChangeMsg
+}
+
+// DomainEventPmsuspendDiskMsg is libvirt's remote_domain_event_pmsuspend_disk_msg
+type DomainEventPmsuspendDiskMsg struct {
+	Dom Domain
+}
+
+// DomainEventCallbackPmsuspendDiskMsg is libvirt's remote_domain_event_callback_pmsuspend_disk_msg
+type DomainEventCallbackPmsuspendDiskMsg struct {
+	CallbackID int32
+	Reason int32
+	Msg DomainEventPmsuspendDiskMsg
+}
+
+// DomainManagedSaveArgs is libvirt's remote_domain_managed_save_args
+type DomainManagedSaveArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainHasManagedSaveImageArgs is libvirt's remote_domain_has_managed_save_image_args
+type DomainHasManagedSaveImageArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainHasManagedSaveImageRet is libvirt's remote_domain_has_managed_save_image_ret
+type DomainHasManagedSaveImageRet struct {
+	Result int32
+}
+
+// DomainManagedSaveRemoveArgs is libvirt's remote_domain_managed_save_remove_args
+type DomainManagedSaveRemoveArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainManagedSaveGetXMLDescArgs is libvirt's remote_domain_managed_save_get_xml_desc_args
+type DomainManagedSaveGetXMLDescArgs struct {
+	Dom Domain
+	Flags DomainXMLFlags
+}
+
+// DomainManagedSaveGetXMLDescRet is libvirt's remote_domain_managed_save_get_xml_desc_ret
+type DomainManagedSaveGetXMLDescRet struct {
+	XML string
+}
+
+// DomainManagedSaveDefineXMLArgs is libvirt's remote_domain_managed_save_define_xml_args
+type DomainManagedSaveDefineXMLArgs struct {
+	Dom Domain
+	Dxml OptString
+	Flags DomainSaveRestoreFlags
+}
+
+// DomainSnapshotCreateXMLArgs is libvirt's remote_domain_snapshot_create_xml_args
+type DomainSnapshotCreateXMLArgs struct {
+	Dom Domain
+	XMLDesc string
+	Flags uint32
+}
+
+// DomainSnapshotCreateXMLRet is libvirt's remote_domain_snapshot_create_xml_ret
+type DomainSnapshotCreateXMLRet struct {
+	Snap DomainSnapshot
+}
+
+// DomainSnapshotGetXMLDescArgs is libvirt's remote_domain_snapshot_get_xml_desc_args
+type DomainSnapshotGetXMLDescArgs struct {
+	Snap DomainSnapshot
+	Flags uint32
+}
+
+// DomainSnapshotGetXMLDescRet is libvirt's remote_domain_snapshot_get_xml_desc_ret
+type DomainSnapshotGetXMLDescRet struct {
+	XML string
+}
+
+// DomainSnapshotNumArgs is libvirt's remote_domain_snapshot_num_args
+type DomainSnapshotNumArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainSnapshotNumRet is libvirt's remote_domain_snapshot_num_ret
+type DomainSnapshotNumRet struct {
+	Num int32
+}
+
+// DomainSnapshotListNamesArgs is libvirt's remote_domain_snapshot_list_names_args
+type DomainSnapshotListNamesArgs struct {
+	Dom Domain
+	Maxnames int32
+	Flags uint32
+}
+
+// DomainSnapshotListNamesRet is libvirt's remote_domain_snapshot_list_names_ret
+type DomainSnapshotListNamesRet struct {
+	Names []string
+}
+
+// DomainListAllSnapshotsArgs is libvirt's remote_domain_list_all_snapshots_args
+type DomainListAllSnapshotsArgs struct {
+	Dom Domain
+	NeedResults int32
+	Flags uint32
+}
+
+// DomainListAllSnapshotsRet is libvirt's remote_domain_list_all_snapshots_ret
+type DomainListAllSnapshotsRet struct {
+	Snapshots []DomainSnapshot
+	Ret int32
+}
+
+// DomainSnapshotNumChildrenArgs is libvirt's remote_domain_snapshot_num_children_args
+type DomainSnapshotNumChildrenArgs struct {
+	Snap DomainSnapshot
+	Flags uint32
+}
+
+// DomainSnapshotNumChildrenRet is libvirt's remote_domain_snapshot_num_children_ret
+type DomainSnapshotNumChildrenRet struct {
+	Num int32
+}
+
+// DomainSnapshotListChildrenNamesArgs is libvirt's remote_domain_snapshot_list_children_names_args
+type DomainSnapshotListChildrenNamesArgs struct {
+	Snap DomainSnapshot
+	Maxnames int32
+	Flags uint32
+}
+
+// DomainSnapshotListChildrenNamesRet is libvirt's remote_domain_snapshot_list_children_names_ret
+type DomainSnapshotListChildrenNamesRet struct {
+	Names []string
+}
+
+// DomainSnapshotListAllChildrenArgs is libvirt's remote_domain_snapshot_list_all_children_args
+type DomainSnapshotListAllChildrenArgs struct {
+	Snapshot DomainSnapshot
+	NeedResults int32
+	Flags uint32
+}
+
+// DomainSnapshotListAllChildrenRet is libvirt's remote_domain_snapshot_list_all_children_ret
+type DomainSnapshotListAllChildrenRet struct {
+	Snapshots []DomainSnapshot
+	Ret int32
+}
+
+// DomainSnapshotLookupByNameArgs is libvirt's remote_domain_snapshot_lookup_by_name_args
+type DomainSnapshotLookupByNameArgs struct {
+	Dom Domain
+	Name string
+	Flags uint32
+}
+
+// DomainSnapshotLookupByNameRet is libvirt's remote_domain_snapshot_lookup_by_name_ret
+type DomainSnapshotLookupByNameRet struct {
+	Snap DomainSnapshot
+}
+
+// DomainHasCurrentSnapshotArgs is libvirt's remote_domain_has_current_snapshot_args
+type DomainHasCurrentSnapshotArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainHasCurrentSnapshotRet is libvirt's remote_domain_has_current_snapshot_ret
+type DomainHasCurrentSnapshotRet struct {
+	Result int32
+}
+
+// DomainSnapshotGetParentArgs is libvirt's remote_domain_snapshot_get_parent_args
+type DomainSnapshotGetParentArgs struct {
+	Snap DomainSnapshot
+	Flags uint32
+}
+
+// DomainSnapshotGetParentRet is libvirt's remote_domain_snapshot_get_parent_ret
+type DomainSnapshotGetParentRet struct {
+	Snap DomainSnapshot
+}
+
+// DomainSnapshotCurrentArgs is libvirt's remote_domain_snapshot_current_args
+type DomainSnapshotCurrentArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainSnapshotCurrentRet is libvirt's remote_domain_snapshot_current_ret
+type DomainSnapshotCurrentRet struct {
+	Snap DomainSnapshot
+}
+
+// DomainSnapshotIsCurrentArgs is libvirt's remote_domain_snapshot_is_current_args
+type DomainSnapshotIsCurrentArgs struct {
+	Snap DomainSnapshot
+	Flags uint32
+}
+
+// DomainSnapshotIsCurrentRet is libvirt's remote_domain_snapshot_is_current_ret
+type DomainSnapshotIsCurrentRet struct {
+	Current int32
+}
+
+// DomainSnapshotHasMetadataArgs is libvirt's remote_domain_snapshot_has_metadata_args
+type DomainSnapshotHasMetadataArgs struct {
+	Snap DomainSnapshot
+	Flags uint32
+}
+
+// DomainSnapshotHasMetadataRet is libvirt's remote_domain_snapshot_has_metadata_ret
+type DomainSnapshotHasMetadataRet struct {
+	Metadata int32
+}
+
+// DomainRevertToSnapshotArgs is libvirt's remote_domain_revert_to_snapshot_args
+type DomainRevertToSnapshotArgs struct {
+	Snap DomainSnapshot
+	Flags uint32
+}
+
+// DomainSnapshotDeleteArgs is libvirt's remote_domain_snapshot_delete_args
+type DomainSnapshotDeleteArgs struct {
+	Snap DomainSnapshot
+	Flags DomainSnapshotDeleteFlags
+}
+
+// DomainOpenConsoleArgs is libvirt's remote_domain_open_console_args
+type DomainOpenConsoleArgs struct {
+	Dom Domain
+	DevName OptString
+	Flags uint32
+}
+
+// DomainOpenChannelArgs is libvirt's remote_domain_open_channel_args
+type DomainOpenChannelArgs struct {
+	Dom Domain
+	Name OptString
+	Flags DomainChannelFlags
+}
+
+// StorageVolUploadArgs is libvirt's remote_storage_vol_upload_args
+type StorageVolUploadArgs struct {
+	Vol StorageVol
+	Offset uint64
+	Length uint64
+	Flags StorageVolUploadFlags
+}
+
+// StorageVolDownloadArgs is libvirt's remote_storage_vol_download_args
+type StorageVolDownloadArgs struct {
+	Vol StorageVol
+	Offset uint64
+	Length uint64
+	Flags StorageVolDownloadFlags
+}
+
+// DomainGetStateArgs is libvirt's remote_domain_get_state_args
+type DomainGetStateArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainGetStateRet is libvirt's remote_domain_get_state_ret
+type DomainGetStateRet struct {
+	State int32
+	Reason int32
+}
+
+// DomainMigrateBegin3Args is libvirt's remote_domain_migrate_begin3_args
+type DomainMigrateBegin3Args struct {
+	Dom Domain
+	Xmlin OptString
+	Flags uint64
+	Dname OptString
+	Resource uint64
+}
+
+// DomainMigrateBegin3Ret is libvirt's remote_domain_migrate_begin3_ret
+type DomainMigrateBegin3Ret struct {
+	CookieOut []byte
+	XML string
+}
+
+// DomainMigratePrepare3Args is libvirt's remote_domain_migrate_prepare3_args
+type DomainMigratePrepare3Args struct {
+	CookieIn []byte
+	UriIn OptString
+	Flags uint64
+	Dname OptString
+	Resource uint64
+	DomXML string
+}
+
+// DomainMigratePrepare3Ret is libvirt's remote_domain_migrate_prepare3_ret
+type DomainMigratePrepare3Ret struct {
+	CookieOut []byte
+	UriOut OptString
+}
+
+// DomainMigratePrepareTunnel3Args is libvirt's remote_domain_migrate_prepare_tunnel3_args
+type DomainMigratePrepareTunnel3Args struct {
+	CookieIn []byte
+	Flags uint64
+	Dname OptString
+	Resource uint64
+	DomXML string
+}
+
+// DomainMigratePrepareTunnel3Ret is libvirt's remote_domain_migrate_prepare_tunnel3_ret
+type DomainMigratePrepareTunnel3Ret struct {
+	CookieOut []byte
+}
+
+// DomainMigratePerform3Args is libvirt's remote_domain_migrate_perform3_args
+type DomainMigratePerform3Args struct {
+	Dom Domain
+	Xmlin OptString
+	CookieIn []byte
+	Dconnuri OptString
+	Uri OptString
+	Flags uint64
+	Dname OptString
+	Resource uint64
+}
+
+// DomainMigratePerform3Ret is libvirt's remote_domain_migrate_perform3_ret
+type DomainMigratePerform3Ret struct {
+	CookieOut []byte
+}
+
+// DomainMigrateFinish3Args is libvirt's remote_domain_migrate_finish3_args
+type DomainMigrateFinish3Args struct {
+	Dname string
+	CookieIn []byte
+	Dconnuri OptString
+	Uri OptString
+	Flags uint64
+	Cancelled int32
+}
+
+// DomainMigrateFinish3Ret is libvirt's remote_domain_migrate_finish3_ret
+type DomainMigrateFinish3Ret struct {
+	Dom Domain
+	CookieOut []byte
+}
+
+// DomainMigrateConfirm3Args is libvirt's remote_domain_migrate_confirm3_args
+type DomainMigrateConfirm3Args struct {
+	Dom Domain
+	CookieIn []byte
+	Flags uint64
+	Cancelled int32
+}
+
+// DomainEventControlErrorMsg is libvirt's remote_domain_event_control_error_msg
+type DomainEventControlErrorMsg struct {
+	Dom Domain
+}
+
+// DomainEventCallbackControlErrorMsg is libvirt's remote_domain_event_callback_control_error_msg
+type DomainEventCallbackControlErrorMsg struct {
+	CallbackID int32
+	Msg DomainEventControlErrorMsg
+}
+
+// DomainGetControlInfoArgs is libvirt's remote_domain_get_control_info_args
+type DomainGetControlInfoArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainGetControlInfoRet is libvirt's remote_domain_get_control_info_ret
+type DomainGetControlInfoRet struct {
+	State uint32
+	Details uint32
+	StateTime uint64
+}
+
+// DomainOpenGraphicsArgs is libvirt's remote_domain_open_graphics_args
+type DomainOpenGraphicsArgs struct {
+	Dom Domain
+	Idx uint32
+	Flags DomainOpenGraphicsFlags
+}
+
+// DomainOpenGraphicsFdArgs is libvirt's remote_domain_open_graphics_fd_args
+type DomainOpenGraphicsFdArgs struct {
+	Dom Domain
+	Idx uint32
+	Flags DomainOpenGraphicsFlags
+}
+
+// NodeSuspendForDurationArgs is libvirt's remote_node_suspend_for_duration_args
+type NodeSuspendForDurationArgs struct {
+	Target uint32
+	Duration uint64
+	Flags uint32
+}
+
+// DomainShutdownFlagsArgs is libvirt's remote_domain_shutdown_flags_args
+type DomainShutdownFlagsArgs struct {
+	Dom Domain
+	Flags DomainShutdownFlagValues
+}
+
+// DomainGetDiskErrorsArgs is libvirt's remote_domain_get_disk_errors_args
+type DomainGetDiskErrorsArgs struct {
+	Dom Domain
+	Maxerrors uint32
+	Flags uint32
+}
+
+// DomainGetDiskErrorsRet is libvirt's remote_domain_get_disk_errors_ret
+type DomainGetDiskErrorsRet struct {
+	Errors []DomainDiskError
+	Nerrors int32
+}
+
+// ConnectListAllDomainsArgs is libvirt's remote_connect_list_all_domains_args
+type ConnectListAllDomainsArgs struct {
+	NeedResults int32
+	Flags ConnectListAllDomainsFlags
+}
+
+// ConnectListAllDomainsRet is libvirt's remote_connect_list_all_domains_ret
+type ConnectListAllDomainsRet struct {
+	Domains []Domain
+	Ret uint32
+}
+
+// ConnectListAllStoragePoolsArgs is libvirt's remote_connect_list_all_storage_pools_args
+type ConnectListAllStoragePoolsArgs struct {
+	NeedResults int32
+	Flags ConnectListAllStoragePoolsFlags
+}
+
+// ConnectListAllStoragePoolsRet is libvirt's remote_connect_list_all_storage_pools_ret
+type ConnectListAllStoragePoolsRet struct {
+	Pools []StoragePool
+	Ret uint32
+}
+
+// StoragePoolListAllVolumesArgs is libvirt's remote_storage_pool_list_all_volumes_args
+type StoragePoolListAllVolumesArgs struct {
+	Pool StoragePool
+	NeedResults int32
+	Flags uint32
+}
+
+// StoragePoolListAllVolumesRet is libvirt's remote_storage_pool_list_all_volumes_ret
+type StoragePoolListAllVolumesRet struct {
+	Vols []StorageVol
+	Ret uint32
+}
+
+// ConnectListAllNetworksArgs is libvirt's remote_connect_list_all_networks_args
+type ConnectListAllNetworksArgs struct {
+	NeedResults int32
+	Flags ConnectListAllNetworksFlags
+}
+
+// ConnectListAllNetworksRet is libvirt's remote_connect_list_all_networks_ret
+type ConnectListAllNetworksRet struct {
+	Nets []Network
+	Ret uint32
+}
+
+// ConnectListAllInterfacesArgs is libvirt's remote_connect_list_all_interfaces_args
+type ConnectListAllInterfacesArgs struct {
+	NeedResults int32
+	Flags ConnectListAllInterfacesFlags
+}
+
+// ConnectListAllInterfacesRet is libvirt's remote_connect_list_all_interfaces_ret
+type ConnectListAllInterfacesRet struct {
+	Ifaces []Interface
+	Ret uint32
+}
+
+// ConnectListAllNodeDevicesArgs is libvirt's remote_connect_list_all_node_devices_args
+type ConnectListAllNodeDevicesArgs struct {
+	NeedResults int32
+	Flags uint32
+}
+
+// ConnectListAllNodeDevicesRet is libvirt's remote_connect_list_all_node_devices_ret
+type ConnectListAllNodeDevicesRet struct {
+	Devices []NodeDevice
+	Ret uint32
+}
+
+// ConnectListAllNwfiltersArgs is libvirt's remote_connect_list_all_nwfilters_args
+type ConnectListAllNwfiltersArgs struct {
+	NeedResults int32
+	Flags uint32
+}
+
+// ConnectListAllNwfiltersRet is libvirt's remote_connect_list_all_nwfilters_ret
+type ConnectListAllNwfiltersRet struct {
+	Filters []Nwfilter
+	Ret uint32
+}
+
+// ConnectListAllSecretsArgs is libvirt's remote_connect_list_all_secrets_args
+type ConnectListAllSecretsArgs struct {
+	NeedResults int32
+	Flags ConnectListAllSecretsFlags
+}
+
+// ConnectListAllSecretsRet is libvirt's remote_connect_list_all_secrets_ret
+type ConnectListAllSecretsRet struct {
+	Secrets []Secret
+	Ret uint32
+}
+
+// NodeSetMemoryParametersArgs is libvirt's remote_node_set_memory_parameters_args
+type NodeSetMemoryParametersArgs struct {
+	Params []TypedParam
+	Flags uint32
+}
+
+// NodeGetMemoryParametersArgs is libvirt's remote_node_get_memory_parameters_args
+type NodeGetMemoryParametersArgs struct {
+	Nparams int32
+	Flags uint32
+}
+
+// NodeGetMemoryParametersRet is libvirt's remote_node_get_memory_parameters_ret
+type NodeGetMemoryParametersRet struct {
+	Params []TypedParam
+	Nparams int32
+}
+
+// NodeGetCPUMapArgs is libvirt's remote_node_get_cpu_map_args
+type NodeGetCPUMapArgs struct {
+	NeedMap int32
+	NeedOnline int32
+	Flags uint32
+}
+
+// NodeGetCPUMapRet is libvirt's remote_node_get_cpu_map_ret
+type NodeGetCPUMapRet struct {
+	Cpumap []byte
+	Online uint32
+	Ret int32
+}
+
+// DomainFstrimArgs is libvirt's remote_domain_fstrim_args
+type DomainFstrimArgs struct {
+	Dom Domain
+	MountPoint OptString
+	Minimum uint64
+	Flags uint32
+}
+
+// DomainGetTimeArgs is libvirt's remote_domain_get_time_args
+type DomainGetTimeArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainGetTimeRet is libvirt's remote_domain_get_time_ret
+type DomainGetTimeRet struct {
+	Seconds int64
+	Nseconds uint32
+}
+
+// DomainSetTimeArgs is libvirt's remote_domain_set_time_args
+type DomainSetTimeArgs struct {
+	Dom Domain
+	Seconds int64
+	Nseconds uint32
+	Flags DomainSetTimeFlags
+}
+
+// DomainMigrateBegin3ParamsArgs is libvirt's remote_domain_migrate_begin3_params_args
+type DomainMigrateBegin3ParamsArgs struct {
+	Dom Domain
+	Params []TypedParam
+	Flags uint32
+}
+
+// DomainMigrateBegin3ParamsRet is libvirt's remote_domain_migrate_begin3_params_ret
+type DomainMigrateBegin3ParamsRet struct {
+	CookieOut []byte
+	XML string
+}
+
+// DomainMigratePrepare3ParamsArgs is libvirt's remote_domain_migrate_prepare3_params_args
+type DomainMigratePrepare3ParamsArgs struct {
+	Params []TypedParam
+	CookieIn []byte
+	Flags uint32
+}
+
+// DomainMigratePrepare3ParamsRet is libvirt's remote_domain_migrate_prepare3_params_ret
+type DomainMigratePrepare3ParamsRet struct {
+	CookieOut []byte
+	UriOut OptString
+}
+
+// DomainMigratePrepareTunnel3ParamsArgs is libvirt's remote_domain_migrate_prepare_tunnel3_params_args
+type DomainMigratePrepareTunnel3ParamsArgs struct {
+	Params []TypedParam
+	CookieIn []byte
+	Flags uint32
+}
+
+// DomainMigratePrepareTunnel3ParamsRet is libvirt's remote_domain_migrate_prepare_tunnel3_params_ret
+type DomainMigratePrepareTunnel3ParamsRet struct {
+	CookieOut []byte
+}
+
+// DomainMigratePerform3ParamsArgs is libvirt's remote_domain_migrate_perform3_params_args
+type DomainMigratePerform3ParamsArgs struct {
+	Dom Domain
+	Dconnuri OptString
+	Params []TypedParam
+	CookieIn []byte
+	Flags DomainMigrateFlags
+}
+
+// DomainMigratePerform3ParamsRet is libvirt's remote_domain_migrate_perform3_params_ret
+type DomainMigratePerform3ParamsRet struct {
+	CookieOut []byte
+}
+
+// DomainMigrateFinish3ParamsArgs is libvirt's remote_domain_migrate_finish3_params_args
+type DomainMigrateFinish3ParamsArgs struct {
+	Params []TypedParam
+	CookieIn []byte
+	Flags uint32
+	Cancelled int32
+}
+
+// DomainMigrateFinish3ParamsRet is libvirt's remote_domain_migrate_finish3_params_ret
+type DomainMigrateFinish3ParamsRet struct {
+	Dom Domain
+	CookieOut []byte
+}
+
+// DomainMigrateConfirm3ParamsArgs is libvirt's remote_domain_migrate_confirm3_params_args
+type DomainMigrateConfirm3ParamsArgs struct {
+	Dom Domain
+	Params []TypedParam
+	CookieIn []byte
+	Flags uint32
+	Cancelled int32
+}
+
+// DomainEventDeviceRemovedMsg is libvirt's remote_domain_event_device_removed_msg
+type DomainEventDeviceRemovedMsg struct {
+	Dom Domain
+	DevAlias string
+}
+
+// DomainEventCallbackDeviceRemovedMsg is libvirt's remote_domain_event_callback_device_removed_msg
+type DomainEventCallbackDeviceRemovedMsg struct {
+	CallbackID int32
+	Msg DomainEventDeviceRemovedMsg
+}
+
+// DomainEventBlockJob2Msg is libvirt's remote_domain_event_block_job_2_msg
+type DomainEventBlockJob2Msg struct {
+	CallbackID int32
+	Dom Domain
+	Dst string
+	Type int32
+	Status int32
+}
+
+// DomainEventBlockThresholdMsg is libvirt's remote_domain_event_block_threshold_msg
+type DomainEventBlockThresholdMsg struct {
+	CallbackID int32
+	Dom Domain
+	Dev string
+	Path OptString
+	Threshold uint64
+	Excess uint64
+}
+
+// DomainEventCallbackTunableMsg is libvirt's remote_domain_event_callback_tunable_msg
+type DomainEventCallbackTunableMsg struct {
+	CallbackID int32
+	Dom Domain
+	Params []TypedParam
+}
+
+// DomainEventCallbackDeviceAddedMsg is libvirt's remote_domain_event_callback_device_added_msg
+type DomainEventCallbackDeviceAddedMsg struct {
+	CallbackID int32
+	Dom Domain
+	DevAlias string
+}
+
+// ConnectEventConnectionClosedMsg is libvirt's remote_connect_event_connection_closed_msg
+type ConnectEventConnectionClosedMsg struct {
+	Reason int32
+}
+
+// ConnectGetCPUModelNamesArgs is libvirt's remote_connect_get_cpu_model_names_args
+type ConnectGetCPUModelNamesArgs struct {
+	Arch string
+	NeedResults int32
+	Flags uint32
+}
+
+// ConnectGetCPUModelNamesRet is libvirt's remote_connect_get_cpu_model_names_ret
+type ConnectGetCPUModelNamesRet struct {
+	Models []string
+	Ret int32
+}
+
+// ConnectNetworkEventRegisterAnyArgs is libvirt's remote_connect_network_event_register_any_args
+type ConnectNetworkEventRegisterAnyArgs struct {
+	EventID int32
+	Net OptNetwork
+}
+
+// ConnectNetworkEventRegisterAnyRet is libvirt's remote_connect_network_event_register_any_ret
+type ConnectNetworkEventRegisterAnyRet struct {
+	CallbackID int32
+}
+
+// ConnectNetworkEventDeregisterAnyArgs is libvirt's remote_connect_network_event_deregister_any_args
+type ConnectNetworkEventDeregisterAnyArgs struct {
+	CallbackID int32
+}
+
+// NetworkEventLifecycleMsg is libvirt's remote_network_event_lifecycle_msg
+type NetworkEventLifecycleMsg struct {
+	CallbackID int32
+	Net Network
+	Event int32
+	Detail int32
+}
+
+// ConnectStoragePoolEventRegisterAnyArgs is libvirt's remote_connect_storage_pool_event_register_any_args
+type ConnectStoragePoolEventRegisterAnyArgs struct {
+	EventID int32
+	Pool OptStoragePool
+}
+
+// ConnectStoragePoolEventRegisterAnyRet is libvirt's remote_connect_storage_pool_event_register_any_ret
+type ConnectStoragePoolEventRegisterAnyRet struct {
+	CallbackID int32
+}
+
+// ConnectStoragePoolEventDeregisterAnyArgs is libvirt's remote_connect_storage_pool_event_deregister_any_args
+type ConnectStoragePoolEventDeregisterAnyArgs struct {
+	CallbackID int32
+}
+
+// StoragePoolEventLifecycleMsg is libvirt's remote_storage_pool_event_lifecycle_msg
+type StoragePoolEventLifecycleMsg struct {
+	CallbackID int32
+	Pool StoragePool
+	Event int32
+	Detail int32
+}
+
+// StoragePoolEventRefreshMsg is libvirt's remote_storage_pool_event_refresh_msg
+type StoragePoolEventRefreshMsg struct {
+	CallbackID int32
+	Pool StoragePool
+}
+
+// ConnectNodeDeviceEventRegisterAnyArgs is libvirt's remote_connect_node_device_event_register_any_args
+type ConnectNodeDeviceEventRegisterAnyArgs struct {
+	EventID int32
+	Dev OptNodeDevice
+}
+
+// ConnectNodeDeviceEventRegisterAnyRet is libvirt's remote_connect_node_device_event_register_any_ret
+type ConnectNodeDeviceEventRegisterAnyRet struct {
+	CallbackID int32
+}
+
+// ConnectNodeDeviceEventDeregisterAnyArgs is libvirt's remote_connect_node_device_event_deregister_any_args
+type ConnectNodeDeviceEventDeregisterAnyArgs struct {
+	CallbackID int32
+}
+
+// NodeDeviceEventLifecycleMsg is libvirt's remote_node_device_event_lifecycle_msg
+type NodeDeviceEventLifecycleMsg struct {
+	CallbackID int32
+	Dev NodeDevice
+	Event int32
+	Detail int32
+}
+
+// NodeDeviceEventUpdateMsg is libvirt's remote_node_device_event_update_msg
+type NodeDeviceEventUpdateMsg struct {
+	CallbackID int32
+	Dev NodeDevice
+}
+
+// DomainFsfreezeArgs is libvirt's remote_domain_fsfreeze_args
+type DomainFsfreezeArgs struct {
+	Dom Domain
+	Mountpoints []string
+	Flags uint32
+}
+
+// DomainFsfreezeRet is libvirt's remote_domain_fsfreeze_ret
+type DomainFsfreezeRet struct {
+	Filesystems int32
+}
+
+// DomainFsthawArgs is libvirt's remote_domain_fsthaw_args
+type DomainFsthawArgs struct {
+	Dom Domain
+	Mountpoints []string
+	Flags uint32
+}
+
+// DomainFsthawRet is libvirt's remote_domain_fsthaw_ret
+type DomainFsthawRet struct {
+	Filesystems int32
+}
+
+// NodeGetFreePagesArgs is libvirt's remote_node_get_free_pages_args
+type NodeGetFreePagesArgs struct {
+	Pages []uint32
+	StartCell int32
+	CellCount uint32
+	Flags uint32
+}
+
+// NodeGetFreePagesRet is libvirt's remote_node_get_free_pages_ret
+type NodeGetFreePagesRet struct {
+	Counts []uint64
+}
+
+// NodeAllocPagesArgs is libvirt's remote_node_alloc_pages_args
+type NodeAllocPagesArgs struct {
+	PageSizes []uint32
+	PageCounts []uint64
+	StartCell int32
+	CellCount uint32
+	Flags NodeAllocPagesFlags
+}
+
+// NodeAllocPagesRet is libvirt's remote_node_alloc_pages_ret
+type NodeAllocPagesRet struct {
+	Ret int32
+}
+
+// NetworkDhcpLease is libvirt's remote_network_dhcp_lease
+type NetworkDhcpLease struct {
+	Iface string
+	Expirytime int64
+	Type int32
+	Mac OptString
+	Iaid OptString
+	Ipaddr string
+	Prefix uint32
+	Hostname OptString
+	Clientid OptString
+}
+
+// NetworkGetDhcpLeasesArgs is libvirt's remote_network_get_dhcp_leases_args
+type NetworkGetDhcpLeasesArgs struct {
+	Net Network
+	Mac OptString
+	NeedResults int32
+	Flags uint32
+}
+
+// NetworkGetDhcpLeasesRet is libvirt's remote_network_get_dhcp_leases_ret
+type NetworkGetDhcpLeasesRet struct {
+	Leases []NetworkDhcpLease
+	Ret uint32
+}
+
+// DomainStatsRecord is libvirt's remote_domain_stats_record
+type DomainStatsRecord struct {
+	Dom Domain
+	Params []TypedParam
+}
+
+// ConnectGetAllDomainStatsArgs is libvirt's remote_connect_get_all_domain_stats_args
+type ConnectGetAllDomainStatsArgs struct {
+	Doms []Domain
+	Stats uint32
+	Flags ConnectGetAllDomainStatsFlags
+}
+
+// DomainEventCallbackAgentLifecycleMsg is libvirt's remote_domain_event_callback_agent_lifecycle_msg
+type DomainEventCallbackAgentLifecycleMsg struct {
+	CallbackID int32
+	Dom Domain
+	State int32
+	Reason int32
+}
+
+// ConnectGetAllDomainStatsRet is libvirt's remote_connect_get_all_domain_stats_ret
+type ConnectGetAllDomainStatsRet struct {
+	RetStats []DomainStatsRecord
+}
+
+// DomainFsinfo is libvirt's remote_domain_fsinfo
+type DomainFsinfo struct {
+	Mountpoint string
+	Name string
+	Fstype string
+	DevAliases []string
+}
+
+// DomainGetFsinfoArgs is libvirt's remote_domain_get_fsinfo_args
+type DomainGetFsinfoArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainGetFsinfoRet is libvirt's remote_domain_get_fsinfo_ret
+type DomainGetFsinfoRet struct {
+	Info []DomainFsinfo
+	Ret uint32
+}
+
+// DomainIPAddr is libvirt's remote_domain_ip_addr
+type DomainIPAddr struct {
+	Type int32
+	Addr string
+	Prefix uint32
+}
+
+// DomainInterface is libvirt's remote_domain_interface
+type DomainInterface struct {
+	Name string
+	Hwaddr OptString
+	Addrs []DomainIPAddr
+}
+
+// DomainInterfaceAddressesArgs is libvirt's remote_domain_interface_addresses_args
+type DomainInterfaceAddressesArgs struct {
+	Dom Domain
+	Source uint32
+	Flags uint32
+}
+
+// DomainInterfaceAddressesRet is libvirt's remote_domain_interface_addresses_ret
+type DomainInterfaceAddressesRet struct {
+	Ifaces []DomainInterface
+}
+
+// DomainSetUserPasswordArgs is libvirt's remote_domain_set_user_password_args
+type DomainSetUserPasswordArgs struct {
+	Dom Domain
+	User OptString
+	Password OptString
+	Flags DomainSetUserPasswordFlags
+}
+
+// DomainRenameArgs is libvirt's remote_domain_rename_args
+type DomainRenameArgs struct {
+	Dom Domain
+	NewName OptString
+	Flags uint32
+}
+
+// DomainRenameRet is libvirt's remote_domain_rename_ret
+type DomainRenameRet struct {
+	Retcode int32
+}
+
+// DomainEventCallbackMigrationIterationMsg is libvirt's remote_domain_event_callback_migration_iteration_msg
+type DomainEventCallbackMigrationIterationMsg struct {
+	CallbackID int32
+	Dom Domain
+	Iteration int32
+}
+
+// DomainEventCallbackJobCompletedMsg is libvirt's remote_domain_event_callback_job_completed_msg
+type DomainEventCallbackJobCompletedMsg struct {
+	CallbackID int32
+	Dom Domain
+	Params []TypedParam
+}
+
+// DomainMigrateStartPostCopyArgs is libvirt's remote_domain_migrate_start_post_copy_args
+type DomainMigrateStartPostCopyArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainEventCallbackDeviceRemovalFailedMsg is libvirt's remote_domain_event_callback_device_removal_failed_msg
+type DomainEventCallbackDeviceRemovalFailedMsg struct {
+	CallbackID int32
+	Dom Domain
+	DevAlias string
+}
+
+// DomainGetGuestVcpusArgs is libvirt's remote_domain_get_guest_vcpus_args
+type DomainGetGuestVcpusArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainGetGuestVcpusRet is libvirt's remote_domain_get_guest_vcpus_ret
+type DomainGetGuestVcpusRet struct {
+	Params []TypedParam
+}
+
+// DomainSetGuestVcpusArgs is libvirt's remote_domain_set_guest_vcpus_args
+type DomainSetGuestVcpusArgs struct {
+	Dom Domain
+	Cpumap string
+	State int32
+	Flags uint32
+}
+
+// DomainSetVcpuArgs is libvirt's remote_domain_set_vcpu_args
+type DomainSetVcpuArgs struct {
+	Dom Domain
+	Cpumap string
+	State int32
+	Flags DomainModificationImpact
+}
+
+// DomainEventCallbackMetadataChangeMsg is libvirt's remote_domain_event_callback_metadata_change_msg
+type DomainEventCallbackMetadataChangeMsg struct {
+	CallbackID int32
+	Dom Domain
+	Type int32
+	Nsuri OptString
+}
+
+// DomainEventMemoryFailureMsg is libvirt's remote_domain_event_memory_failure_msg
+type DomainEventMemoryFailureMsg struct {
+	CallbackID int32
+	Dom Domain
+	Recipient int32
+	Action int32
+	Flags uint32
+}
+
+// ConnectSecretEventRegisterAnyArgs is libvirt's remote_connect_secret_event_register_any_args
+type ConnectSecretEventRegisterAnyArgs struct {
+	EventID int32
+	OptSecret OptSecret
+}
+
+// ConnectSecretEventRegisterAnyRet is libvirt's remote_connect_secret_event_register_any_ret
+type ConnectSecretEventRegisterAnyRet struct {
+	CallbackID int32
+}
+
+// ConnectSecretEventDeregisterAnyArgs is libvirt's remote_connect_secret_event_deregister_any_args
+type ConnectSecretEventDeregisterAnyArgs struct {
+	CallbackID int32
+}
+
+// SecretEventLifecycleMsg is libvirt's remote_secret_event_lifecycle_msg
+type SecretEventLifecycleMsg struct {
+	CallbackID int32
+	OptSecret Secret
+	Event int32
+	Detail int32
+}
+
+// SecretEventValueChangedMsg is libvirt's remote_secret_event_value_changed_msg
+type SecretEventValueChangedMsg struct {
+	CallbackID int32
+	OptSecret Secret
+}
+
+// DomainSetBlockThresholdArgs is libvirt's remote_domain_set_block_threshold_args
+type DomainSetBlockThresholdArgs struct {
+	Dom Domain
+	Dev string
+	Threshold uint64
+	Flags uint32
+}
+
+// DomainSetLifecycleActionArgs is libvirt's remote_domain_set_lifecycle_action_args
+type DomainSetLifecycleActionArgs struct {
+	Dom Domain
+	Type uint32
+	Action uint32
+	Flags DomainModificationImpact
+}
+
+// ConnectCompareHypervisorCPUArgs is libvirt's remote_connect_compare_hypervisor_cpu_args
+type ConnectCompareHypervisorCPUArgs struct {
+	Emulator OptString
+	Arch OptString
+	Machine OptString
+	Virttype OptString
+	XMLCPU string
+	Flags uint32
+}
+
+// ConnectCompareHypervisorCPURet is libvirt's remote_connect_compare_hypervisor_cpu_ret
+type ConnectCompareHypervisorCPURet struct {
+	Result int32
+}
+
+// ConnectBaselineHypervisorCPUArgs is libvirt's remote_connect_baseline_hypervisor_cpu_args
+type ConnectBaselineHypervisorCPUArgs struct {
+	Emulator OptString
+	Arch OptString
+	Machine OptString
+	Virttype OptString
+	XMLCPUs []string
+	Flags uint32
+}
+
+// ConnectBaselineHypervisorCPURet is libvirt's remote_connect_baseline_hypervisor_cpu_ret
+type ConnectBaselineHypervisorCPURet struct {
+	CPU string
+}
+
+// NodeGetSevInfoArgs is libvirt's remote_node_get_sev_info_args
+type NodeGetSevInfoArgs struct {
+	Nparams int32
+	Flags uint32
+}
+
+// NodeGetSevInfoRet is libvirt's remote_node_get_sev_info_ret
+type NodeGetSevInfoRet struct {
+	Params []TypedParam
+	Nparams int32
+}
+
+// DomainGetLaunchSecurityInfoArgs is libvirt's remote_domain_get_launch_security_info_args
+type DomainGetLaunchSecurityInfoArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainGetLaunchSecurityInfoRet is libvirt's remote_domain_get_launch_security_info_ret
+type DomainGetLaunchSecurityInfoRet struct {
+	Params []TypedParam
+}
+
+// NwfilterBindingLookupByPortDevArgs is libvirt's remote_nwfilter_binding_lookup_by_port_dev_args
+type NwfilterBindingLookupByPortDevArgs struct {
+	Name string
+}
+
+// NwfilterBindingLookupByPortDevRet is libvirt's remote_nwfilter_binding_lookup_by_port_dev_ret
+type NwfilterBindingLookupByPortDevRet struct {
+	OptNwfilter NwfilterBinding
+}
+
+// NwfilterBindingCreateXMLArgs is libvirt's remote_nwfilter_binding_create_xml_args
+type NwfilterBindingCreateXMLArgs struct {
+	XML string
+	Flags uint32
+}
+
+// NwfilterBindingCreateXMLRet is libvirt's remote_nwfilter_binding_create_xml_ret
+type NwfilterBindingCreateXMLRet struct {
+	OptNwfilter NwfilterBinding
+}
+
+// NwfilterBindingDeleteArgs is libvirt's remote_nwfilter_binding_delete_args
+type NwfilterBindingDeleteArgs struct {
+	OptNwfilter NwfilterBinding
+}
+
+// NwfilterBindingGetXMLDescArgs is libvirt's remote_nwfilter_binding_get_xml_desc_args
+type NwfilterBindingGetXMLDescArgs struct {
+	OptNwfilter NwfilterBinding
+	Flags uint32
+}
+
+// NwfilterBindingGetXMLDescRet is libvirt's remote_nwfilter_binding_get_xml_desc_ret
+type NwfilterBindingGetXMLDescRet struct {
+	XML string
+}
+
+// ConnectListAllNwfilterBindingsArgs is libvirt's remote_connect_list_all_nwfilter_bindings_args
+type ConnectListAllNwfilterBindingsArgs struct {
+	NeedResults int32
+	Flags uint32
+}
+
+// ConnectListAllNwfilterBindingsRet is libvirt's remote_connect_list_all_nwfilter_bindings_ret
+type ConnectListAllNwfilterBindingsRet struct {
+	Bindings []NwfilterBinding
+	Ret uint32
+}
+
+// ConnectGetStoragePoolCapabilitiesArgs is libvirt's remote_connect_get_storage_pool_capabilities_args
+type ConnectGetStoragePoolCapabilitiesArgs struct {
+	Flags uint32
+}
+
+// ConnectGetStoragePoolCapabilitiesRet is libvirt's remote_connect_get_storage_pool_capabilities_ret
+type ConnectGetStoragePoolCapabilitiesRet struct {
+	Capabilities string
+}
+
+// NetworkListAllPortsArgs is libvirt's remote_network_list_all_ports_args
+type NetworkListAllPortsArgs struct {
+	OptNetwork Network
+	NeedResults int32
+	Flags uint32
+}
+
+// NetworkListAllPortsRet is libvirt's remote_network_list_all_ports_ret
+type NetworkListAllPortsRet struct {
+	Ports []NetworkPort
+	Ret uint32
+}
+
+// NetworkPortLookupByUUIDArgs is libvirt's remote_network_port_lookup_by_uuid_args
+type NetworkPortLookupByUUIDArgs struct {
+	OptNetwork Network
+	UUID UUID
+}
+
+// NetworkPortLookupByUUIDRet is libvirt's remote_network_port_lookup_by_uuid_ret
+type NetworkPortLookupByUUIDRet struct {
+	Port NetworkPort
+}
+
+// NetworkPortCreateXMLArgs is libvirt's remote_network_port_create_xml_args
+type NetworkPortCreateXMLArgs struct {
+	OptNetwork Network
+	XML string
+	Flags uint32
+}
+
+// NetworkPortCreateXMLRet is libvirt's remote_network_port_create_xml_ret
+type NetworkPortCreateXMLRet struct {
+	Port NetworkPort
+}
+
+// NetworkPortSetParametersArgs is libvirt's remote_network_port_set_parameters_args
+type NetworkPortSetParametersArgs struct {
+	Port NetworkPort
+	Params []TypedParam
+	Flags uint32
+}
+
+// NetworkPortGetParametersArgs is libvirt's remote_network_port_get_parameters_args
+type NetworkPortGetParametersArgs struct {
+	Port NetworkPort
+	Nparams int32
+	Flags uint32
+}
+
+// NetworkPortGetParametersRet is libvirt's remote_network_port_get_parameters_ret
+type NetworkPortGetParametersRet struct {
+	Params []TypedParam
+	Nparams int32
+}
+
+// NetworkPortGetXMLDescArgs is libvirt's remote_network_port_get_xml_desc_args
+type NetworkPortGetXMLDescArgs struct {
+	Port NetworkPort
+	Flags uint32
+}
+
+// NetworkPortGetXMLDescRet is libvirt's remote_network_port_get_xml_desc_ret
+type NetworkPortGetXMLDescRet struct {
+	XML string
+}
+
+// NetworkPortDeleteArgs is libvirt's remote_network_port_delete_args
+type NetworkPortDeleteArgs struct {
+	Port NetworkPort
+	Flags uint32
+}
+
+// DomainCheckpointCreateXMLArgs is libvirt's remote_domain_checkpoint_create_xml_args
+type DomainCheckpointCreateXMLArgs struct {
+	Dom Domain
+	XMLDesc string
+	Flags uint32
+}
+
+// DomainCheckpointCreateXMLRet is libvirt's remote_domain_checkpoint_create_xml_ret
+type DomainCheckpointCreateXMLRet struct {
+	Checkpoint DomainCheckpoint
+}
+
+// DomainCheckpointGetXMLDescArgs is libvirt's remote_domain_checkpoint_get_xml_desc_args
+type DomainCheckpointGetXMLDescArgs struct {
+	Checkpoint DomainCheckpoint
+	Flags uint32
+}
+
+// DomainCheckpointGetXMLDescRet is libvirt's remote_domain_checkpoint_get_xml_desc_ret
+type DomainCheckpointGetXMLDescRet struct {
+	XML string
+}
+
+// DomainListAllCheckpointsArgs is libvirt's remote_domain_list_all_checkpoints_args
+type DomainListAllCheckpointsArgs struct {
+	Dom Domain
+	NeedResults int32
+	Flags uint32
+}
+
+// DomainListAllCheckpointsRet is libvirt's remote_domain_list_all_checkpoints_ret
+type DomainListAllCheckpointsRet struct {
+	Checkpoints []DomainCheckpoint
+	Ret int32
+}
+
+// DomainCheckpointListAllChildrenArgs is libvirt's remote_domain_checkpoint_list_all_children_args
+type DomainCheckpointListAllChildrenArgs struct {
+	Checkpoint DomainCheckpoint
+	NeedResults int32
+	Flags uint32
+}
+
+// DomainCheckpointListAllChildrenRet is libvirt's remote_domain_checkpoint_list_all_children_ret
+type DomainCheckpointListAllChildrenRet struct {
+	Checkpoints []DomainCheckpoint
+	Ret int32
+}
+
+// DomainCheckpointLookupByNameArgs is libvirt's remote_domain_checkpoint_lookup_by_name_args
+type DomainCheckpointLookupByNameArgs struct {
+	Dom Domain
+	Name string
+	Flags uint32
+}
+
+// DomainCheckpointLookupByNameRet is libvirt's remote_domain_checkpoint_lookup_by_name_ret
+type DomainCheckpointLookupByNameRet struct {
+	Checkpoint DomainCheckpoint
+}
+
+// DomainCheckpointGetParentArgs is libvirt's remote_domain_checkpoint_get_parent_args
+type DomainCheckpointGetParentArgs struct {
+	Checkpoint DomainCheckpoint
+	Flags uint32
+}
+
+// DomainCheckpointGetParentRet is libvirt's remote_domain_checkpoint_get_parent_ret
+type DomainCheckpointGetParentRet struct {
+	Parent DomainCheckpoint
+}
+
+// DomainCheckpointDeleteArgs is libvirt's remote_domain_checkpoint_delete_args
+type DomainCheckpointDeleteArgs struct {
+	Checkpoint DomainCheckpoint
+	Flags DomainCheckpointDeleteFlags
+}
+
+// DomainGetGuestInfoArgs is libvirt's remote_domain_get_guest_info_args
+type DomainGetGuestInfoArgs struct {
+	Dom Domain
+	Types uint32
+	Flags uint32
+}
+
+// DomainGetGuestInfoRet is libvirt's remote_domain_get_guest_info_ret
+type DomainGetGuestInfoRet struct {
+	Params []TypedParam
+}
+
+// ConnectSetIdentityArgs is libvirt's remote_connect_set_identity_args
+type ConnectSetIdentityArgs struct {
+	Params []TypedParam
+	Flags uint32
+}
+
+// DomainAgentSetResponseTimeoutArgs is libvirt's remote_domain_agent_set_response_timeout_args
+type DomainAgentSetResponseTimeoutArgs struct {
+	Dom Domain
+	Timeout int32
+	Flags uint32
+}
+
+// DomainAgentSetResponseTimeoutRet is libvirt's remote_domain_agent_set_response_timeout_ret
+type DomainAgentSetResponseTimeoutRet struct {
+	Result int32
+}
+
+// DomainBackupBeginArgs is libvirt's remote_domain_backup_begin_args
+type DomainBackupBeginArgs struct {
+	Dom Domain
+	BackupXML string
+	CheckpointXML OptString
+	Flags DomainBackupBeginFlags
+}
+
+// DomainBackupGetXMLDescArgs is libvirt's remote_domain_backup_get_xml_desc_args
+type DomainBackupGetXMLDescArgs struct {
+	Dom Domain
+	Flags uint32
+}
+
+// DomainBackupGetXMLDescRet is libvirt's remote_domain_backup_get_xml_desc_ret
+type DomainBackupGetXMLDescRet struct {
+	XML string
+}
+
+// DomainAuthorizedSshKeysGetArgs is libvirt's remote_domain_authorized_ssh_keys_get_args
+type DomainAuthorizedSshKeysGetArgs struct {
+	Dom Domain
+	User string
+	Flags uint32
+}
+
+// DomainAuthorizedSshKeysGetRet is libvirt's remote_domain_authorized_ssh_keys_get_ret
+type DomainAuthorizedSshKeysGetRet struct {
+	Keys []string
+}
+
+// DomainAuthorizedSshKeysSetArgs is libvirt's remote_domain_authorized_ssh_keys_set_args
+type DomainAuthorizedSshKeysSetArgs struct {
+	Dom Domain
+	User string
+	Keys []string
+	Flags uint32
+}
+
+
+// TypedParamValue is a discriminated union.
+type TypedParamValue struct {
+	D uint32
+	I interface{}
+}
+
+// NewTypedParamValueInt creates a discriminated union value satisfying
+// the TypedParamValue interface.
+func NewTypedParamValueInt(v int32) *TypedParamValue {
+	return &TypedParamValue{D: 1, I: v}
+}
+
+// NewTypedParamValueUint creates a discriminated union value satisfying
+// the TypedParamValue interface.
+func NewTypedParamValueUint(v uint32) *TypedParamValue {
+	return &TypedParamValue{D: 2, I: v}
+}
+
+// NewTypedParamValueLlong creates a discriminated union value satisfying
+// the TypedParamValue interface.
+func NewTypedParamValueLlong(v int64) *TypedParamValue {
+	return &TypedParamValue{D: 3, I: v}
+}
+
+// NewTypedParamValueUllong creates a discriminated union value satisfying
+// the TypedParamValue interface.
+func NewTypedParamValueUllong(v uint64) *TypedParamValue {
+	return &TypedParamValue{D: 4, I: v}
+}
+
+// NewTypedParamValueDouble creates a discriminated union value satisfying
+// the TypedParamValue interface.
+func NewTypedParamValueDouble(v float64) *TypedParamValue {
+	return &TypedParamValue{D: 5, I: v}
+}
+
+// NewTypedParamValueBoolean creates a discriminated union value satisfying
+// the TypedParamValue interface.
+func NewTypedParamValueBoolean(v int32) *TypedParamValue {
+	return &TypedParamValue{D: 6, I: v}
+}
+
+// NewTypedParamValueString creates a discriminated union value satisfying
+// the TypedParamValue interface.
+func NewTypedParamValueString(v string) *TypedParamValue {
+	return &TypedParamValue{D: 7, I: v}
+}
+
+
+// ConnectOpen is the go wrapper for REMOTE_PROC_CONNECT_OPEN.
+func (l *Libvirt) ConnectOpen(Name OptString, Flags ConnectFlags) (err error) {
+	var buf []byte
+
+	args := ConnectOpenArgs {
+		Name: Name,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(1, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectClose is the go wrapper for REMOTE_PROC_CONNECT_CLOSE.
+func (l *Libvirt) ConnectClose() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(2, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectGetType is the go wrapper for REMOTE_PROC_CONNECT_GET_TYPE.
+func (l *Libvirt) ConnectGetType() (rType string, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(3, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Type: string
+	_, err = dec.Decode(&rType)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectGetVersion is the go wrapper for REMOTE_PROC_CONNECT_GET_VERSION.
+func (l *Libvirt) ConnectGetVersion() (rHvVer uint64, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(4, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// HvVer: uint64
+	_, err = dec.Decode(&rHvVer)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectGetMaxVcpus is the go wrapper for REMOTE_PROC_CONNECT_GET_MAX_VCPUS.
+func (l *Libvirt) ConnectGetMaxVcpus(Type OptString) (rMaxVcpus int32, err error) {
+	var buf []byte
+
+	args := ConnectGetMaxVcpusArgs {
+		Type: Type,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(5, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// MaxVcpus: int32
+	_, err = dec.Decode(&rMaxVcpus)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeGetInfo is the go wrapper for REMOTE_PROC_NODE_GET_INFO.
+func (l *Libvirt) NodeGetInfo() (rModel [32]int8, rMemory uint64, rCpus int32, rMhz int32, rNodes int32, rSockets int32, rCores int32, rThreads int32, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(6, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Model: [32]int8
+	_, err = dec.Decode(&rModel)
+	if err != nil {
+		return
+	}
+	// Memory: uint64
+	_, err = dec.Decode(&rMemory)
+	if err != nil {
+		return
+	}
+	// Cpus: int32
+	_, err = dec.Decode(&rCpus)
+	if err != nil {
+		return
+	}
+	// Mhz: int32
+	_, err = dec.Decode(&rMhz)
+	if err != nil {
+		return
+	}
+	// Nodes: int32
+	_, err = dec.Decode(&rNodes)
+	if err != nil {
+		return
+	}
+	// Sockets: int32
+	_, err = dec.Decode(&rSockets)
+	if err != nil {
+		return
+	}
+	// Cores: int32
+	_, err = dec.Decode(&rCores)
+	if err != nil {
+		return
+	}
+	// Threads: int32
+	_, err = dec.Decode(&rThreads)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectGetCapabilities is the go wrapper for REMOTE_PROC_CONNECT_GET_CAPABILITIES.
+func (l *Libvirt) ConnectGetCapabilities() (rCapabilities string, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(7, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Capabilities: string
+	_, err = dec.Decode(&rCapabilities)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainAttachDevice is the go wrapper for REMOTE_PROC_DOMAIN_ATTACH_DEVICE.
+func (l *Libvirt) DomainAttachDevice(Dom Domain, XML string) (err error) {
+	var buf []byte
+
+	args := DomainAttachDeviceArgs {
+		Dom: Dom,
+		XML: XML,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(8, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainCreate is the go wrapper for REMOTE_PROC_DOMAIN_CREATE.
+func (l *Libvirt) DomainCreate(Dom Domain) (err error) {
+	var buf []byte
+
+	args := DomainCreateArgs {
+		Dom: Dom,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(9, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainCreateXML is the go wrapper for REMOTE_PROC_DOMAIN_CREATE_XML.
+func (l *Libvirt) DomainCreateXML(XMLDesc string, Flags DomainCreateFlags) (rDom Domain, err error) {
+	var buf []byte
+
+	args := DomainCreateXMLArgs {
+		XMLDesc: XMLDesc,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(10, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Dom: Domain
+	_, err = dec.Decode(&rDom)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainDefineXML is the go wrapper for REMOTE_PROC_DOMAIN_DEFINE_XML.
+func (l *Libvirt) DomainDefineXML(XML string) (rDom Domain, err error) {
+	var buf []byte
+
+	args := DomainDefineXMLArgs {
+		XML: XML,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(11, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Dom: Domain
+	_, err = dec.Decode(&rDom)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainDestroy is the go wrapper for REMOTE_PROC_DOMAIN_DESTROY.
+func (l *Libvirt) DomainDestroy(Dom Domain) (err error) {
+	var buf []byte
+
+	args := DomainDestroyArgs {
+		Dom: Dom,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(12, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainDetachDevice is the go wrapper for REMOTE_PROC_DOMAIN_DETACH_DEVICE.
+func (l *Libvirt) DomainDetachDevice(Dom Domain, XML string) (err error) {
+	var buf []byte
+
+	args := DomainDetachDeviceArgs {
+		Dom: Dom,
+		XML: XML,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(13, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetXMLDesc is the go wrapper for REMOTE_PROC_DOMAIN_GET_XML_DESC.
+func (l *Libvirt) DomainGetXMLDesc(Dom Domain, Flags DomainXMLFlags) (rXML string, err error) {
+	var buf []byte
+
+	args := DomainGetXMLDescArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(14, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// XML: string
+	_, err = dec.Decode(&rXML)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetAutostart is the go wrapper for REMOTE_PROC_DOMAIN_GET_AUTOSTART.
+func (l *Libvirt) DomainGetAutostart(Dom Domain) (rAutostart int32, err error) {
+	var buf []byte
+
+	args := DomainGetAutostartArgs {
+		Dom: Dom,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(15, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Autostart: int32
+	_, err = dec.Decode(&rAutostart)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetInfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_INFO.
+func (l *Libvirt) DomainGetInfo(Dom Domain) (rState uint8, rMaxMem uint64, rMemory uint64, rNrVirtCPU uint16, rCPUTime uint64, err error) {
+	var buf []byte
+
+	args := DomainGetInfoArgs {
+		Dom: Dom,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(16, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// State: uint8
+	_, err = dec.Decode(&rState)
+	if err != nil {
+		return
+	}
+	// MaxMem: uint64
+	_, err = dec.Decode(&rMaxMem)
+	if err != nil {
+		return
+	}
+	// Memory: uint64
+	_, err = dec.Decode(&rMemory)
+	if err != nil {
+		return
+	}
+	// NrVirtCPU: uint16
+	_, err = dec.Decode(&rNrVirtCPU)
+	if err != nil {
+		return
+	}
+	// CPUTime: uint64
+	_, err = dec.Decode(&rCPUTime)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetMaxMemory is the go wrapper for REMOTE_PROC_DOMAIN_GET_MAX_MEMORY.
+func (l *Libvirt) DomainGetMaxMemory(Dom Domain) (rMemory uint64, err error) {
+	var buf []byte
+
+	args := DomainGetMaxMemoryArgs {
+		Dom: Dom,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(17, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Memory: uint64
+	_, err = dec.Decode(&rMemory)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetMaxVcpus is the go wrapper for REMOTE_PROC_DOMAIN_GET_MAX_VCPUS.
+func (l *Libvirt) DomainGetMaxVcpus(Dom Domain) (rNum int32, err error) {
+	var buf []byte
+
+	args := DomainGetMaxVcpusArgs {
+		Dom: Dom,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(18, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Num: int32
+	_, err = dec.Decode(&rNum)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetOsType is the go wrapper for REMOTE_PROC_DOMAIN_GET_OS_TYPE.
+func (l *Libvirt) DomainGetOsType(Dom Domain) (rType string, err error) {
+	var buf []byte
+
+	args := DomainGetOsTypeArgs {
+		Dom: Dom,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(19, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Type: string
+	_, err = dec.Decode(&rType)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetVcpus is the go wrapper for REMOTE_PROC_DOMAIN_GET_VCPUS.
+func (l *Libvirt) DomainGetVcpus(Dom Domain, Maxinfo int32, Maplen int32) (rInfo []VcpuInfo, rCpumaps []byte, err error) {
+	var buf []byte
+
+	args := DomainGetVcpusArgs {
+		Dom: Dom,
+		Maxinfo: Maxinfo,
+		Maplen: Maplen,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(20, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Info: []VcpuInfo
+	_, err = dec.Decode(&rInfo)
+	if err != nil {
+		return
+	}
+	// Cpumaps: []byte
+	_, err = dec.Decode(&rCpumaps)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectListDefinedDomains is the go wrapper for REMOTE_PROC_CONNECT_LIST_DEFINED_DOMAINS.
+func (l *Libvirt) ConnectListDefinedDomains(Maxnames int32) (rNames []string, err error) {
+	var buf []byte
+
+	args := ConnectListDefinedDomainsArgs {
+		Maxnames: Maxnames,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(21, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Names: []string
+	_, err = dec.Decode(&rNames)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainLookupByID is the go wrapper for REMOTE_PROC_DOMAIN_LOOKUP_BY_ID.
+func (l *Libvirt) DomainLookupByID(ID int32) (rDom Domain, err error) {
+	var buf []byte
+
+	args := DomainLookupByIDArgs {
+		ID: ID,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(22, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Dom: Domain
+	_, err = dec.Decode(&rDom)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainLookupByName is the go wrapper for REMOTE_PROC_DOMAIN_LOOKUP_BY_NAME.
+func (l *Libvirt) DomainLookupByName(Name string) (rDom Domain, err error) {
+	var buf []byte
+
+	args := DomainLookupByNameArgs {
+		Name: Name,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(23, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Dom: Domain
+	_, err = dec.Decode(&rDom)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainLookupByUUID is the go wrapper for REMOTE_PROC_DOMAIN_LOOKUP_BY_UUID.
+func (l *Libvirt) DomainLookupByUUID(UUID UUID) (rDom Domain, err error) {
+	var buf []byte
+
+	args := DomainLookupByUUIDArgs {
+		UUID: UUID,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(24, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Dom: Domain
+	_, err = dec.Decode(&rDom)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectNumOfDefinedDomains is the go wrapper for REMOTE_PROC_CONNECT_NUM_OF_DEFINED_DOMAINS.
+func (l *Libvirt) ConnectNumOfDefinedDomains() (rNum int32, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(25, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Num: int32
+	_, err = dec.Decode(&rNum)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainPinVcpu is the go wrapper for REMOTE_PROC_DOMAIN_PIN_VCPU.
+func (l *Libvirt) DomainPinVcpu(Dom Domain, Vcpu uint32, Cpumap []byte) (err error) {
+	var buf []byte
+
+	args := DomainPinVcpuArgs {
+		Dom: Dom,
+		Vcpu: Vcpu,
+		Cpumap: Cpumap,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(26, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainReboot is the go wrapper for REMOTE_PROC_DOMAIN_REBOOT.
+func (l *Libvirt) DomainReboot(Dom Domain, Flags DomainRebootFlagValues) (err error) {
+	var buf []byte
+
+	args := DomainRebootArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(27, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainResume is the go wrapper for REMOTE_PROC_DOMAIN_RESUME.
+func (l *Libvirt) DomainResume(Dom Domain) (err error) {
+	var buf []byte
+
+	args := DomainResumeArgs {
+		Dom: Dom,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(28, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetAutostart is the go wrapper for REMOTE_PROC_DOMAIN_SET_AUTOSTART.
+func (l *Libvirt) DomainSetAutostart(Dom Domain, Autostart int32) (err error) {
+	var buf []byte
+
+	args := DomainSetAutostartArgs {
+		Dom: Dom,
+		Autostart: Autostart,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(29, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetMaxMemory is the go wrapper for REMOTE_PROC_DOMAIN_SET_MAX_MEMORY.
+func (l *Libvirt) DomainSetMaxMemory(Dom Domain, Memory uint64) (err error) {
+	var buf []byte
+
+	args := DomainSetMaxMemoryArgs {
+		Dom: Dom,
+		Memory: Memory,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(30, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetMemory is the go wrapper for REMOTE_PROC_DOMAIN_SET_MEMORY.
+func (l *Libvirt) DomainSetMemory(Dom Domain, Memory uint64) (err error) {
+	var buf []byte
+
+	args := DomainSetMemoryArgs {
+		Dom: Dom,
+		Memory: Memory,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(31, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetVcpus is the go wrapper for REMOTE_PROC_DOMAIN_SET_VCPUS.
+func (l *Libvirt) DomainSetVcpus(Dom Domain, Nvcpus uint32) (err error) {
+	var buf []byte
+
+	args := DomainSetVcpusArgs {
+		Dom: Dom,
+		Nvcpus: Nvcpus,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(32, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainShutdown is the go wrapper for REMOTE_PROC_DOMAIN_SHUTDOWN.
+func (l *Libvirt) DomainShutdown(Dom Domain) (err error) {
+	var buf []byte
+
+	args := DomainShutdownArgs {
+		Dom: Dom,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(33, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSuspend is the go wrapper for REMOTE_PROC_DOMAIN_SUSPEND.
+func (l *Libvirt) DomainSuspend(Dom Domain) (err error) {
+	var buf []byte
+
+	args := DomainSuspendArgs {
+		Dom: Dom,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(34, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainUndefine is the go wrapper for REMOTE_PROC_DOMAIN_UNDEFINE.
+func (l *Libvirt) DomainUndefine(Dom Domain) (err error) {
+	var buf []byte
+
+	args := DomainUndefineArgs {
+		Dom: Dom,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(35, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectListDefinedNetworks is the go wrapper for REMOTE_PROC_CONNECT_LIST_DEFINED_NETWORKS.
+func (l *Libvirt) ConnectListDefinedNetworks(Maxnames int32) (rNames []string, err error) {
+	var buf []byte
+
+	args := ConnectListDefinedNetworksArgs {
+		Maxnames: Maxnames,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(36, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Names: []string
+	_, err = dec.Decode(&rNames)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectListDomains is the go wrapper for REMOTE_PROC_CONNECT_LIST_DOMAINS.
+func (l *Libvirt) ConnectListDomains(Maxids int32) (rIds []int32, err error) {
+	var buf []byte
+
+	args := ConnectListDomainsArgs {
+		Maxids: Maxids,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(37, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Ids: []int32
+	_, err = dec.Decode(&rIds)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectListNetworks is the go wrapper for REMOTE_PROC_CONNECT_LIST_NETWORKS.
+func (l *Libvirt) ConnectListNetworks(Maxnames int32) (rNames []string, err error) {
+	var buf []byte
+
+	args := ConnectListNetworksArgs {
+		Maxnames: Maxnames,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(38, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Names: []string
+	_, err = dec.Decode(&rNames)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkCreate is the go wrapper for REMOTE_PROC_NETWORK_CREATE.
+func (l *Libvirt) NetworkCreate(Net Network) (err error) {
+	var buf []byte
+
+	args := NetworkCreateArgs {
+		Net: Net,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(39, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkCreateXML is the go wrapper for REMOTE_PROC_NETWORK_CREATE_XML.
+func (l *Libvirt) NetworkCreateXML(XML string) (rNet Network, err error) {
+	var buf []byte
+
+	args := NetworkCreateXMLArgs {
+		XML: XML,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(40, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Net: Network
+	_, err = dec.Decode(&rNet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkDefineXML is the go wrapper for REMOTE_PROC_NETWORK_DEFINE_XML.
+func (l *Libvirt) NetworkDefineXML(XML string) (rNet Network, err error) {
+	var buf []byte
+
+	args := NetworkDefineXMLArgs {
+		XML: XML,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(41, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Net: Network
+	_, err = dec.Decode(&rNet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkDestroy is the go wrapper for REMOTE_PROC_NETWORK_DESTROY.
+func (l *Libvirt) NetworkDestroy(Net Network) (err error) {
+	var buf []byte
+
+	args := NetworkDestroyArgs {
+		Net: Net,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(42, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkGetXMLDesc is the go wrapper for REMOTE_PROC_NETWORK_GET_XML_DESC.
+func (l *Libvirt) NetworkGetXMLDesc(Net Network, Flags uint32) (rXML string, err error) {
+	var buf []byte
+
+	args := NetworkGetXMLDescArgs {
+		Net: Net,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(43, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// XML: string
+	_, err = dec.Decode(&rXML)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkGetAutostart is the go wrapper for REMOTE_PROC_NETWORK_GET_AUTOSTART.
+func (l *Libvirt) NetworkGetAutostart(Net Network) (rAutostart int32, err error) {
+	var buf []byte
+
+	args := NetworkGetAutostartArgs {
+		Net: Net,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(44, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Autostart: int32
+	_, err = dec.Decode(&rAutostart)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkGetBridgeName is the go wrapper for REMOTE_PROC_NETWORK_GET_BRIDGE_NAME.
+func (l *Libvirt) NetworkGetBridgeName(Net Network) (rName string, err error) {
+	var buf []byte
+
+	args := NetworkGetBridgeNameArgs {
+		Net: Net,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(45, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Name: string
+	_, err = dec.Decode(&rName)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkLookupByName is the go wrapper for REMOTE_PROC_NETWORK_LOOKUP_BY_NAME.
+func (l *Libvirt) NetworkLookupByName(Name string) (rNet Network, err error) {
+	var buf []byte
+
+	args := NetworkLookupByNameArgs {
+		Name: Name,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(46, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Net: Network
+	_, err = dec.Decode(&rNet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkLookupByUUID is the go wrapper for REMOTE_PROC_NETWORK_LOOKUP_BY_UUID.
+func (l *Libvirt) NetworkLookupByUUID(UUID UUID) (rNet Network, err error) {
+	var buf []byte
+
+	args := NetworkLookupByUUIDArgs {
+		UUID: UUID,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(47, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Net: Network
+	_, err = dec.Decode(&rNet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkSetAutostart is the go wrapper for REMOTE_PROC_NETWORK_SET_AUTOSTART.
+func (l *Libvirt) NetworkSetAutostart(Net Network, Autostart int32) (err error) {
+	var buf []byte
+
+	args := NetworkSetAutostartArgs {
+		Net: Net,
+		Autostart: Autostart,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(48, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkUndefine is the go wrapper for REMOTE_PROC_NETWORK_UNDEFINE.
+func (l *Libvirt) NetworkUndefine(Net Network) (err error) {
+	var buf []byte
+
+	args := NetworkUndefineArgs {
+		Net: Net,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(49, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectNumOfDefinedNetworks is the go wrapper for REMOTE_PROC_CONNECT_NUM_OF_DEFINED_NETWORKS.
+func (l *Libvirt) ConnectNumOfDefinedNetworks() (rNum int32, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(50, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Num: int32
+	_, err = dec.Decode(&rNum)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectNumOfDomains is the go wrapper for REMOTE_PROC_CONNECT_NUM_OF_DOMAINS.
+func (l *Libvirt) ConnectNumOfDomains() (rNum int32, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(51, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Num: int32
+	_, err = dec.Decode(&rNum)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectNumOfNetworks is the go wrapper for REMOTE_PROC_CONNECT_NUM_OF_NETWORKS.
+func (l *Libvirt) ConnectNumOfNetworks() (rNum int32, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(52, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Num: int32
+	_, err = dec.Decode(&rNum)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainCoreDump is the go wrapper for REMOTE_PROC_DOMAIN_CORE_DUMP.
+func (l *Libvirt) DomainCoreDump(Dom Domain, To string, Flags DomainCoreDumpFlags) (err error) {
+	var buf []byte
+
+	args := DomainCoreDumpArgs {
+		Dom: Dom,
+		To: To,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(53, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainRestore is the go wrapper for REMOTE_PROC_DOMAIN_RESTORE.
+func (l *Libvirt) DomainRestore(From string) (err error) {
+	var buf []byte
+
+	args := DomainRestoreArgs {
+		From: From,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(54, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSave is the go wrapper for REMOTE_PROC_DOMAIN_SAVE.
+func (l *Libvirt) DomainSave(Dom Domain, To string) (err error) {
+	var buf []byte
+
+	args := DomainSaveArgs {
+		Dom: Dom,
+		To: To,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(55, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetSchedulerType is the go wrapper for REMOTE_PROC_DOMAIN_GET_SCHEDULER_TYPE.
+func (l *Libvirt) DomainGetSchedulerType(Dom Domain) (rType string, rNparams int32, err error) {
+	var buf []byte
+
+	args := DomainGetSchedulerTypeArgs {
+		Dom: Dom,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(56, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Type: string
+	_, err = dec.Decode(&rType)
+	if err != nil {
+		return
+	}
+	// Nparams: int32
+	_, err = dec.Decode(&rNparams)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetSchedulerParameters is the go wrapper for REMOTE_PROC_DOMAIN_GET_SCHEDULER_PARAMETERS.
+func (l *Libvirt) DomainGetSchedulerParameters(Dom Domain, Nparams int32) (rParams []TypedParam, err error) {
+	var buf []byte
+
+	args := DomainGetSchedulerParametersArgs {
+		Dom: Dom,
+		Nparams: Nparams,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(57, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Params: []TypedParam
+	_, err = dec.Decode(&rParams)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetSchedulerParameters is the go wrapper for REMOTE_PROC_DOMAIN_SET_SCHEDULER_PARAMETERS.
+func (l *Libvirt) DomainSetSchedulerParameters(Dom Domain, Params []TypedParam) (err error) {
+	var buf []byte
+
+	args := DomainSetSchedulerParametersArgs {
+		Dom: Dom,
+		Params: Params,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(58, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectGetHostname is the go wrapper for REMOTE_PROC_CONNECT_GET_HOSTNAME.
+func (l *Libvirt) ConnectGetHostname() (rHostname string, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(59, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Hostname: string
+	_, err = dec.Decode(&rHostname)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectSupportsFeature is the go wrapper for REMOTE_PROC_CONNECT_SUPPORTS_FEATURE.
+func (l *Libvirt) ConnectSupportsFeature(Feature int32) (rSupported int32, err error) {
+	var buf []byte
+
+	args := ConnectSupportsFeatureArgs {
+		Feature: Feature,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(60, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Supported: int32
+	_, err = dec.Decode(&rSupported)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigratePrepare is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_PREPARE.
+func (l *Libvirt) DomainMigratePrepare(UriIn OptString, Flags uint64, Dname OptString, Resource uint64) (rCookie []byte, rUriOut OptString, err error) {
+	var buf []byte
+
+	args := DomainMigratePrepareArgs {
+		UriIn: UriIn,
+		Flags: Flags,
+		Dname: Dname,
+		Resource: Resource,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(61, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Cookie: []byte
+	_, err = dec.Decode(&rCookie)
+	if err != nil {
+		return
+	}
+	// UriOut: OptString
+	_, err = dec.Decode(&rUriOut)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigratePerform is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_PERFORM.
+func (l *Libvirt) DomainMigratePerform(Dom Domain, Cookie []byte, Uri string, Flags uint64, Dname OptString, Resource uint64) (err error) {
+	var buf []byte
+
+	args := DomainMigratePerformArgs {
+		Dom: Dom,
+		Cookie: Cookie,
+		Uri: Uri,
+		Flags: Flags,
+		Dname: Dname,
+		Resource: Resource,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(62, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigrateFinish is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_FINISH.
+func (l *Libvirt) DomainMigrateFinish(Dname string, Cookie []byte, Uri string, Flags uint64) (rDdom Domain, err error) {
+	var buf []byte
+
+	args := DomainMigrateFinishArgs {
+		Dname: Dname,
+		Cookie: Cookie,
+		Uri: Uri,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(63, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Ddom: Domain
+	_, err = dec.Decode(&rDdom)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainBlockStats is the go wrapper for REMOTE_PROC_DOMAIN_BLOCK_STATS.
+func (l *Libvirt) DomainBlockStats(Dom Domain, Path string) (rRdReq int64, rRdBytes int64, rWrReq int64, rWrBytes int64, rErrs int64, err error) {
+	var buf []byte
+
+	args := DomainBlockStatsArgs {
+		Dom: Dom,
+		Path: Path,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(64, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// RdReq: int64
+	_, err = dec.Decode(&rRdReq)
+	if err != nil {
+		return
+	}
+	// RdBytes: int64
+	_, err = dec.Decode(&rRdBytes)
+	if err != nil {
+		return
+	}
+	// WrReq: int64
+	_, err = dec.Decode(&rWrReq)
+	if err != nil {
+		return
+	}
+	// WrBytes: int64
+	_, err = dec.Decode(&rWrBytes)
+	if err != nil {
+		return
+	}
+	// Errs: int64
+	_, err = dec.Decode(&rErrs)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainInterfaceStats is the go wrapper for REMOTE_PROC_DOMAIN_INTERFACE_STATS.
+func (l *Libvirt) DomainInterfaceStats(Dom Domain, Device string) (rRxBytes int64, rRxPackets int64, rRxErrs int64, rRxDrop int64, rTxBytes int64, rTxPackets int64, rTxErrs int64, rTxDrop int64, err error) {
+	var buf []byte
+
+	args := DomainInterfaceStatsArgs {
+		Dom: Dom,
+		Device: Device,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(65, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// RxBytes: int64
+	_, err = dec.Decode(&rRxBytes)
+	if err != nil {
+		return
+	}
+	// RxPackets: int64
+	_, err = dec.Decode(&rRxPackets)
+	if err != nil {
+		return
+	}
+	// RxErrs: int64
+	_, err = dec.Decode(&rRxErrs)
+	if err != nil {
+		return
+	}
+	// RxDrop: int64
+	_, err = dec.Decode(&rRxDrop)
+	if err != nil {
+		return
+	}
+	// TxBytes: int64
+	_, err = dec.Decode(&rTxBytes)
+	if err != nil {
+		return
+	}
+	// TxPackets: int64
+	_, err = dec.Decode(&rTxPackets)
+	if err != nil {
+		return
+	}
+	// TxErrs: int64
+	_, err = dec.Decode(&rTxErrs)
+	if err != nil {
+		return
+	}
+	// TxDrop: int64
+	_, err = dec.Decode(&rTxDrop)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// AuthList is the go wrapper for REMOTE_PROC_AUTH_LIST.
+func (l *Libvirt) AuthList() (rTypes []AuthType, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(66, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Types: []AuthType
+	_, err = dec.Decode(&rTypes)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// AuthSaslInit is the go wrapper for REMOTE_PROC_AUTH_SASL_INIT.
+func (l *Libvirt) AuthSaslInit() (rMechlist string, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(67, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Mechlist: string
+	_, err = dec.Decode(&rMechlist)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// AuthSaslStart is the go wrapper for REMOTE_PROC_AUTH_SASL_START.
+func (l *Libvirt) AuthSaslStart(Mech string, Nil int32, Data []int8) (rComplete int32, rNil int32, rData []int8, err error) {
+	var buf []byte
+
+	args := AuthSaslStartArgs {
+		Mech: Mech,
+		Nil: Nil,
+		Data: Data,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(68, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Complete: int32
+	_, err = dec.Decode(&rComplete)
+	if err != nil {
+		return
+	}
+	// Nil: int32
+	_, err = dec.Decode(&rNil)
+	if err != nil {
+		return
+	}
+	// Data: []int8
+	_, err = dec.Decode(&rData)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// AuthSaslStep is the go wrapper for REMOTE_PROC_AUTH_SASL_STEP.
+func (l *Libvirt) AuthSaslStep(Nil int32, Data []int8) (rComplete int32, rNil int32, rData []int8, err error) {
+	var buf []byte
+
+	args := AuthSaslStepArgs {
+		Nil: Nil,
+		Data: Data,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(69, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Complete: int32
+	_, err = dec.Decode(&rComplete)
+	if err != nil {
+		return
+	}
+	// Nil: int32
+	_, err = dec.Decode(&rNil)
+	if err != nil {
+		return
+	}
+	// Data: []int8
+	_, err = dec.Decode(&rData)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// AuthPolkit is the go wrapper for REMOTE_PROC_AUTH_POLKIT.
+func (l *Libvirt) AuthPolkit() (rComplete int32, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(70, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Complete: int32
+	_, err = dec.Decode(&rComplete)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectNumOfStoragePools is the go wrapper for REMOTE_PROC_CONNECT_NUM_OF_STORAGE_POOLS.
+func (l *Libvirt) ConnectNumOfStoragePools() (rNum int32, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(71, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Num: int32
+	_, err = dec.Decode(&rNum)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectListStoragePools is the go wrapper for REMOTE_PROC_CONNECT_LIST_STORAGE_POOLS.
+func (l *Libvirt) ConnectListStoragePools(Maxnames int32) (rNames []string, err error) {
+	var buf []byte
+
+	args := ConnectListStoragePoolsArgs {
+		Maxnames: Maxnames,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(72, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Names: []string
+	_, err = dec.Decode(&rNames)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectNumOfDefinedStoragePools is the go wrapper for REMOTE_PROC_CONNECT_NUM_OF_DEFINED_STORAGE_POOLS.
+func (l *Libvirt) ConnectNumOfDefinedStoragePools() (rNum int32, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(73, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Num: int32
+	_, err = dec.Decode(&rNum)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectListDefinedStoragePools is the go wrapper for REMOTE_PROC_CONNECT_LIST_DEFINED_STORAGE_POOLS.
+func (l *Libvirt) ConnectListDefinedStoragePools(Maxnames int32) (rNames []string, err error) {
+	var buf []byte
+
+	args := ConnectListDefinedStoragePoolsArgs {
+		Maxnames: Maxnames,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(74, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Names: []string
+	_, err = dec.Decode(&rNames)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectFindStoragePoolSources is the go wrapper for REMOTE_PROC_CONNECT_FIND_STORAGE_POOL_SOURCES.
+func (l *Libvirt) ConnectFindStoragePoolSources(Type string, SrcSpec OptString, Flags uint32) (rXML string, err error) {
+	var buf []byte
+
+	args := ConnectFindStoragePoolSourcesArgs {
+		Type: Type,
+		SrcSpec: SrcSpec,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(75, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// XML: string
+	_, err = dec.Decode(&rXML)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolCreateXML is the go wrapper for REMOTE_PROC_STORAGE_POOL_CREATE_XML.
+func (l *Libvirt) StoragePoolCreateXML(XML string, Flags StoragePoolCreateFlags) (rPool StoragePool, err error) {
+	var buf []byte
+
+	args := StoragePoolCreateXMLArgs {
+		XML: XML,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(76, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Pool: StoragePool
+	_, err = dec.Decode(&rPool)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolDefineXML is the go wrapper for REMOTE_PROC_STORAGE_POOL_DEFINE_XML.
+func (l *Libvirt) StoragePoolDefineXML(XML string, Flags uint32) (rPool StoragePool, err error) {
+	var buf []byte
+
+	args := StoragePoolDefineXMLArgs {
+		XML: XML,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(77, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Pool: StoragePool
+	_, err = dec.Decode(&rPool)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolCreate is the go wrapper for REMOTE_PROC_STORAGE_POOL_CREATE.
+func (l *Libvirt) StoragePoolCreate(Pool StoragePool, Flags StoragePoolCreateFlags) (err error) {
+	var buf []byte
+
+	args := StoragePoolCreateArgs {
+		Pool: Pool,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(78, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolBuild is the go wrapper for REMOTE_PROC_STORAGE_POOL_BUILD.
+func (l *Libvirt) StoragePoolBuild(Pool StoragePool, Flags StoragePoolBuildFlags) (err error) {
+	var buf []byte
+
+	args := StoragePoolBuildArgs {
+		Pool: Pool,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(79, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolDestroy is the go wrapper for REMOTE_PROC_STORAGE_POOL_DESTROY.
+func (l *Libvirt) StoragePoolDestroy(Pool StoragePool) (err error) {
+	var buf []byte
+
+	args := StoragePoolDestroyArgs {
+		Pool: Pool,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(80, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolDelete is the go wrapper for REMOTE_PROC_STORAGE_POOL_DELETE.
+func (l *Libvirt) StoragePoolDelete(Pool StoragePool, Flags StoragePoolDeleteFlags) (err error) {
+	var buf []byte
+
+	args := StoragePoolDeleteArgs {
+		Pool: Pool,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(81, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolUndefine is the go wrapper for REMOTE_PROC_STORAGE_POOL_UNDEFINE.
+func (l *Libvirt) StoragePoolUndefine(Pool StoragePool) (err error) {
+	var buf []byte
+
+	args := StoragePoolUndefineArgs {
+		Pool: Pool,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(82, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolRefresh is the go wrapper for REMOTE_PROC_STORAGE_POOL_REFRESH.
+func (l *Libvirt) StoragePoolRefresh(Pool StoragePool, Flags uint32) (err error) {
+	var buf []byte
+
+	args := StoragePoolRefreshArgs {
+		Pool: Pool,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(83, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolLookupByName is the go wrapper for REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_NAME.
+func (l *Libvirt) StoragePoolLookupByName(Name string) (rPool StoragePool, err error) {
+	var buf []byte
+
+	args := StoragePoolLookupByNameArgs {
+		Name: Name,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(84, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Pool: StoragePool
+	_, err = dec.Decode(&rPool)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolLookupByUUID is the go wrapper for REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_UUID.
+func (l *Libvirt) StoragePoolLookupByUUID(UUID UUID) (rPool StoragePool, err error) {
+	var buf []byte
+
+	args := StoragePoolLookupByUUIDArgs {
+		UUID: UUID,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(85, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Pool: StoragePool
+	_, err = dec.Decode(&rPool)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolLookupByVolume is the go wrapper for REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_VOLUME.
+func (l *Libvirt) StoragePoolLookupByVolume(Vol StorageVol) (rPool StoragePool, err error) {
+	var buf []byte
+
+	args := StoragePoolLookupByVolumeArgs {
+		Vol: Vol,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(86, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Pool: StoragePool
+	_, err = dec.Decode(&rPool)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolGetInfo is the go wrapper for REMOTE_PROC_STORAGE_POOL_GET_INFO.
+func (l *Libvirt) StoragePoolGetInfo(Pool StoragePool) (rState uint8, rCapacity uint64, rAllocation uint64, rAvailable uint64, err error) {
+	var buf []byte
+
+	args := StoragePoolGetInfoArgs {
+		Pool: Pool,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(87, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// State: uint8
+	_, err = dec.Decode(&rState)
+	if err != nil {
+		return
+	}
+	// Capacity: uint64
+	_, err = dec.Decode(&rCapacity)
+	if err != nil {
+		return
+	}
+	// Allocation: uint64
+	_, err = dec.Decode(&rAllocation)
+	if err != nil {
+		return
+	}
+	// Available: uint64
+	_, err = dec.Decode(&rAvailable)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolGetXMLDesc is the go wrapper for REMOTE_PROC_STORAGE_POOL_GET_XML_DESC.
+func (l *Libvirt) StoragePoolGetXMLDesc(Pool StoragePool, Flags StorageXMLFlags) (rXML string, err error) {
+	var buf []byte
+
+	args := StoragePoolGetXMLDescArgs {
+		Pool: Pool,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(88, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// XML: string
+	_, err = dec.Decode(&rXML)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolGetAutostart is the go wrapper for REMOTE_PROC_STORAGE_POOL_GET_AUTOSTART.
+func (l *Libvirt) StoragePoolGetAutostart(Pool StoragePool) (rAutostart int32, err error) {
+	var buf []byte
+
+	args := StoragePoolGetAutostartArgs {
+		Pool: Pool,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(89, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Autostart: int32
+	_, err = dec.Decode(&rAutostart)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolSetAutostart is the go wrapper for REMOTE_PROC_STORAGE_POOL_SET_AUTOSTART.
+func (l *Libvirt) StoragePoolSetAutostart(Pool StoragePool, Autostart int32) (err error) {
+	var buf []byte
+
+	args := StoragePoolSetAutostartArgs {
+		Pool: Pool,
+		Autostart: Autostart,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(90, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolNumOfVolumes is the go wrapper for REMOTE_PROC_STORAGE_POOL_NUM_OF_VOLUMES.
+func (l *Libvirt) StoragePoolNumOfVolumes(Pool StoragePool) (rNum int32, err error) {
+	var buf []byte
+
+	args := StoragePoolNumOfVolumesArgs {
+		Pool: Pool,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(91, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Num: int32
+	_, err = dec.Decode(&rNum)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolListVolumes is the go wrapper for REMOTE_PROC_STORAGE_POOL_LIST_VOLUMES.
+func (l *Libvirt) StoragePoolListVolumes(Pool StoragePool, Maxnames int32) (rNames []string, err error) {
+	var buf []byte
+
+	args := StoragePoolListVolumesArgs {
+		Pool: Pool,
+		Maxnames: Maxnames,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(92, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Names: []string
+	_, err = dec.Decode(&rNames)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StorageVolCreateXML is the go wrapper for REMOTE_PROC_STORAGE_VOL_CREATE_XML.
+func (l *Libvirt) StorageVolCreateXML(Pool StoragePool, XML string, Flags StorageVolCreateFlags) (rVol StorageVol, err error) {
+	var buf []byte
+
+	args := StorageVolCreateXMLArgs {
+		Pool: Pool,
+		XML: XML,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(93, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Vol: StorageVol
+	_, err = dec.Decode(&rVol)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StorageVolDelete is the go wrapper for REMOTE_PROC_STORAGE_VOL_DELETE.
+func (l *Libvirt) StorageVolDelete(Vol StorageVol, Flags StorageVolDeleteFlags) (err error) {
+	var buf []byte
+
+	args := StorageVolDeleteArgs {
+		Vol: Vol,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(94, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StorageVolLookupByName is the go wrapper for REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_NAME.
+func (l *Libvirt) StorageVolLookupByName(Pool StoragePool, Name string) (rVol StorageVol, err error) {
+	var buf []byte
+
+	args := StorageVolLookupByNameArgs {
+		Pool: Pool,
+		Name: Name,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(95, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Vol: StorageVol
+	_, err = dec.Decode(&rVol)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StorageVolLookupByKey is the go wrapper for REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_KEY.
+func (l *Libvirt) StorageVolLookupByKey(Key string) (rVol StorageVol, err error) {
+	var buf []byte
+
+	args := StorageVolLookupByKeyArgs {
+		Key: Key,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(96, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Vol: StorageVol
+	_, err = dec.Decode(&rVol)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StorageVolLookupByPath is the go wrapper for REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_PATH.
+func (l *Libvirt) StorageVolLookupByPath(Path string) (rVol StorageVol, err error) {
+	var buf []byte
+
+	args := StorageVolLookupByPathArgs {
+		Path: Path,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(97, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Vol: StorageVol
+	_, err = dec.Decode(&rVol)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StorageVolGetInfo is the go wrapper for REMOTE_PROC_STORAGE_VOL_GET_INFO.
+func (l *Libvirt) StorageVolGetInfo(Vol StorageVol) (rType int8, rCapacity uint64, rAllocation uint64, err error) {
+	var buf []byte
+
+	args := StorageVolGetInfoArgs {
+		Vol: Vol,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(98, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Type: int8
+	_, err = dec.Decode(&rType)
+	if err != nil {
+		return
+	}
+	// Capacity: uint64
+	_, err = dec.Decode(&rCapacity)
+	if err != nil {
+		return
+	}
+	// Allocation: uint64
+	_, err = dec.Decode(&rAllocation)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StorageVolGetXMLDesc is the go wrapper for REMOTE_PROC_STORAGE_VOL_GET_XML_DESC.
+func (l *Libvirt) StorageVolGetXMLDesc(Vol StorageVol, Flags uint32) (rXML string, err error) {
+	var buf []byte
+
+	args := StorageVolGetXMLDescArgs {
+		Vol: Vol,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(99, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// XML: string
+	_, err = dec.Decode(&rXML)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StorageVolGetPath is the go wrapper for REMOTE_PROC_STORAGE_VOL_GET_PATH.
+func (l *Libvirt) StorageVolGetPath(Vol StorageVol) (rName string, err error) {
+	var buf []byte
+
+	args := StorageVolGetPathArgs {
+		Vol: Vol,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(100, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Name: string
+	_, err = dec.Decode(&rName)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeGetCellsFreeMemory is the go wrapper for REMOTE_PROC_NODE_GET_CELLS_FREE_MEMORY.
+func (l *Libvirt) NodeGetCellsFreeMemory(StartCell int32, Maxcells int32) (rCells []uint64, err error) {
+	var buf []byte
+
+	args := NodeGetCellsFreeMemoryArgs {
+		StartCell: StartCell,
+		Maxcells: Maxcells,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(101, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Cells: []uint64
+	_, err = dec.Decode(&rCells)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeGetFreeMemory is the go wrapper for REMOTE_PROC_NODE_GET_FREE_MEMORY.
+func (l *Libvirt) NodeGetFreeMemory() (rFreeMem uint64, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(102, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// FreeMem: uint64
+	_, err = dec.Decode(&rFreeMem)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainBlockPeek is the go wrapper for REMOTE_PROC_DOMAIN_BLOCK_PEEK.
+func (l *Libvirt) DomainBlockPeek(Dom Domain, Path string, Offset uint64, Size uint32, Flags uint32) (rBuffer []byte, err error) {
+	var buf []byte
+
+	args := DomainBlockPeekArgs {
+		Dom: Dom,
+		Path: Path,
+		Offset: Offset,
+		Size: Size,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(103, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Buffer: []byte
+	_, err = dec.Decode(&rBuffer)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMemoryPeek is the go wrapper for REMOTE_PROC_DOMAIN_MEMORY_PEEK.
+func (l *Libvirt) DomainMemoryPeek(Dom Domain, Offset uint64, Size uint32, Flags DomainMemoryFlags) (rBuffer []byte, err error) {
+	var buf []byte
+
+	args := DomainMemoryPeekArgs {
+		Dom: Dom,
+		Offset: Offset,
+		Size: Size,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(104, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Buffer: []byte
+	_, err = dec.Decode(&rBuffer)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectDomainEventRegister is the go wrapper for REMOTE_PROC_CONNECT_DOMAIN_EVENT_REGISTER.
+func (l *Libvirt) ConnectDomainEventRegister() (rCbRegistered int32, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(105, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// CbRegistered: int32
+	_, err = dec.Decode(&rCbRegistered)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectDomainEventDeregister is the go wrapper for REMOTE_PROC_CONNECT_DOMAIN_EVENT_DEREGISTER.
+func (l *Libvirt) ConnectDomainEventDeregister() (rCbRegistered int32, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(106, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// CbRegistered: int32
+	_, err = dec.Decode(&rCbRegistered)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventLifecycle is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_LIFECYCLE.
+func (l *Libvirt) DomainEventLifecycle() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(107, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigratePrepare2 is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_PREPARE2.
+func (l *Libvirt) DomainMigratePrepare2(UriIn OptString, Flags uint64, Dname OptString, Resource uint64, DomXML string) (rCookie []byte, rUriOut OptString, err error) {
+	var buf []byte
+
+	args := DomainMigratePrepare2Args {
+		UriIn: UriIn,
+		Flags: Flags,
+		Dname: Dname,
+		Resource: Resource,
+		DomXML: DomXML,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(108, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Cookie: []byte
+	_, err = dec.Decode(&rCookie)
+	if err != nil {
+		return
+	}
+	// UriOut: OptString
+	_, err = dec.Decode(&rUriOut)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigrateFinish2 is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_FINISH2.
+func (l *Libvirt) DomainMigrateFinish2(Dname string, Cookie []byte, Uri string, Flags uint64, Retcode int32) (rDdom Domain, err error) {
+	var buf []byte
+
+	args := DomainMigrateFinish2Args {
+		Dname: Dname,
+		Cookie: Cookie,
+		Uri: Uri,
+		Flags: Flags,
+		Retcode: Retcode,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(109, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Ddom: Domain
+	_, err = dec.Decode(&rDdom)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectGetUri is the go wrapper for REMOTE_PROC_CONNECT_GET_URI.
+func (l *Libvirt) ConnectGetUri() (rUri string, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(110, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Uri: string
+	_, err = dec.Decode(&rUri)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeNumOfDevices is the go wrapper for REMOTE_PROC_NODE_NUM_OF_DEVICES.
+func (l *Libvirt) NodeNumOfDevices(Cap OptString, Flags uint32) (rNum int32, err error) {
+	var buf []byte
+
+	args := NodeNumOfDevicesArgs {
+		Cap: Cap,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(111, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Num: int32
+	_, err = dec.Decode(&rNum)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeListDevices is the go wrapper for REMOTE_PROC_NODE_LIST_DEVICES.
+func (l *Libvirt) NodeListDevices(Cap OptString, Maxnames int32, Flags uint32) (rNames []string, err error) {
+	var buf []byte
+
+	args := NodeListDevicesArgs {
+		Cap: Cap,
+		Maxnames: Maxnames,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(112, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Names: []string
+	_, err = dec.Decode(&rNames)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeDeviceLookupByName is the go wrapper for REMOTE_PROC_NODE_DEVICE_LOOKUP_BY_NAME.
+func (l *Libvirt) NodeDeviceLookupByName(Name string) (rDev NodeDevice, err error) {
+	var buf []byte
+
+	args := NodeDeviceLookupByNameArgs {
+		Name: Name,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(113, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Dev: NodeDevice
+	_, err = dec.Decode(&rDev)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeDeviceGetXMLDesc is the go wrapper for REMOTE_PROC_NODE_DEVICE_GET_XML_DESC.
+func (l *Libvirt) NodeDeviceGetXMLDesc(Name string, Flags uint32) (rXML string, err error) {
+	var buf []byte
+
+	args := NodeDeviceGetXMLDescArgs {
+		Name: Name,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(114, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// XML: string
+	_, err = dec.Decode(&rXML)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeDeviceGetParent is the go wrapper for REMOTE_PROC_NODE_DEVICE_GET_PARENT.
+func (l *Libvirt) NodeDeviceGetParent(Name string) (rParentName OptString, err error) {
+	var buf []byte
+
+	args := NodeDeviceGetParentArgs {
+		Name: Name,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(115, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// ParentName: OptString
+	_, err = dec.Decode(&rParentName)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeDeviceNumOfCaps is the go wrapper for REMOTE_PROC_NODE_DEVICE_NUM_OF_CAPS.
+func (l *Libvirt) NodeDeviceNumOfCaps(Name string) (rNum int32, err error) {
+	var buf []byte
+
+	args := NodeDeviceNumOfCapsArgs {
+		Name: Name,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(116, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Num: int32
+	_, err = dec.Decode(&rNum)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeDeviceListCaps is the go wrapper for REMOTE_PROC_NODE_DEVICE_LIST_CAPS.
+func (l *Libvirt) NodeDeviceListCaps(Name string, Maxnames int32) (rNames []string, err error) {
+	var buf []byte
+
+	args := NodeDeviceListCapsArgs {
+		Name: Name,
+		Maxnames: Maxnames,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(117, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Names: []string
+	_, err = dec.Decode(&rNames)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeDeviceDettach is the go wrapper for REMOTE_PROC_NODE_DEVICE_DETTACH.
+func (l *Libvirt) NodeDeviceDettach(Name string) (err error) {
+	var buf []byte
+
+	args := NodeDeviceDettachArgs {
+		Name: Name,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(118, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeDeviceReAttach is the go wrapper for REMOTE_PROC_NODE_DEVICE_RE_ATTACH.
+func (l *Libvirt) NodeDeviceReAttach(Name string) (err error) {
+	var buf []byte
+
+	args := NodeDeviceReAttachArgs {
+		Name: Name,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(119, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeDeviceReset is the go wrapper for REMOTE_PROC_NODE_DEVICE_RESET.
+func (l *Libvirt) NodeDeviceReset(Name string) (err error) {
+	var buf []byte
+
+	args := NodeDeviceResetArgs {
+		Name: Name,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(120, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetSecurityLabel is the go wrapper for REMOTE_PROC_DOMAIN_GET_SECURITY_LABEL.
+func (l *Libvirt) DomainGetSecurityLabel(Dom Domain) (rLabel []int8, rEnforcing int32, err error) {
+	var buf []byte
+
+	args := DomainGetSecurityLabelArgs {
+		Dom: Dom,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(121, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Label: []int8
+	_, err = dec.Decode(&rLabel)
+	if err != nil {
+		return
+	}
+	// Enforcing: int32
+	_, err = dec.Decode(&rEnforcing)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeGetSecurityModel is the go wrapper for REMOTE_PROC_NODE_GET_SECURITY_MODEL.
+func (l *Libvirt) NodeGetSecurityModel() (rModel []int8, rDoi []int8, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(122, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Model: []int8
+	_, err = dec.Decode(&rModel)
+	if err != nil {
+		return
+	}
+	// Doi: []int8
+	_, err = dec.Decode(&rDoi)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeDeviceCreateXML is the go wrapper for REMOTE_PROC_NODE_DEVICE_CREATE_XML.
+func (l *Libvirt) NodeDeviceCreateXML(XMLDesc string, Flags uint32) (rDev NodeDevice, err error) {
+	var buf []byte
+
+	args := NodeDeviceCreateXMLArgs {
+		XMLDesc: XMLDesc,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(123, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Dev: NodeDevice
+	_, err = dec.Decode(&rDev)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeDeviceDestroy is the go wrapper for REMOTE_PROC_NODE_DEVICE_DESTROY.
+func (l *Libvirt) NodeDeviceDestroy(Name string) (err error) {
+	var buf []byte
+
+	args := NodeDeviceDestroyArgs {
+		Name: Name,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(124, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StorageVolCreateXMLFrom is the go wrapper for REMOTE_PROC_STORAGE_VOL_CREATE_XML_FROM.
+func (l *Libvirt) StorageVolCreateXMLFrom(Pool StoragePool, XML string, Clonevol StorageVol, Flags StorageVolCreateFlags) (rVol StorageVol, err error) {
+	var buf []byte
+
+	args := StorageVolCreateXMLFromArgs {
+		Pool: Pool,
+		XML: XML,
+		Clonevol: Clonevol,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(125, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Vol: StorageVol
+	_, err = dec.Decode(&rVol)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectNumOfInterfaces is the go wrapper for REMOTE_PROC_CONNECT_NUM_OF_INTERFACES.
+func (l *Libvirt) ConnectNumOfInterfaces() (rNum int32, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(126, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Num: int32
+	_, err = dec.Decode(&rNum)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectListInterfaces is the go wrapper for REMOTE_PROC_CONNECT_LIST_INTERFACES.
+func (l *Libvirt) ConnectListInterfaces(Maxnames int32) (rNames []string, err error) {
+	var buf []byte
+
+	args := ConnectListInterfacesArgs {
+		Maxnames: Maxnames,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(127, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Names: []string
+	_, err = dec.Decode(&rNames)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// InterfaceLookupByName is the go wrapper for REMOTE_PROC_INTERFACE_LOOKUP_BY_NAME.
+func (l *Libvirt) InterfaceLookupByName(Name string) (rIface Interface, err error) {
+	var buf []byte
+
+	args := InterfaceLookupByNameArgs {
+		Name: Name,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(128, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Iface: Interface
+	_, err = dec.Decode(&rIface)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// InterfaceLookupByMacString is the go wrapper for REMOTE_PROC_INTERFACE_LOOKUP_BY_MAC_STRING.
+func (l *Libvirt) InterfaceLookupByMacString(Mac string) (rIface Interface, err error) {
+	var buf []byte
+
+	args := InterfaceLookupByMacStringArgs {
+		Mac: Mac,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(129, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Iface: Interface
+	_, err = dec.Decode(&rIface)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// InterfaceGetXMLDesc is the go wrapper for REMOTE_PROC_INTERFACE_GET_XML_DESC.
+func (l *Libvirt) InterfaceGetXMLDesc(Iface Interface, Flags uint32) (rXML string, err error) {
+	var buf []byte
+
+	args := InterfaceGetXMLDescArgs {
+		Iface: Iface,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(130, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// XML: string
+	_, err = dec.Decode(&rXML)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// InterfaceDefineXML is the go wrapper for REMOTE_PROC_INTERFACE_DEFINE_XML.
+func (l *Libvirt) InterfaceDefineXML(XML string, Flags uint32) (rIface Interface, err error) {
+	var buf []byte
+
+	args := InterfaceDefineXMLArgs {
+		XML: XML,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(131, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Iface: Interface
+	_, err = dec.Decode(&rIface)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// InterfaceUndefine is the go wrapper for REMOTE_PROC_INTERFACE_UNDEFINE.
+func (l *Libvirt) InterfaceUndefine(Iface Interface) (err error) {
+	var buf []byte
+
+	args := InterfaceUndefineArgs {
+		Iface: Iface,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(132, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// InterfaceCreate is the go wrapper for REMOTE_PROC_INTERFACE_CREATE.
+func (l *Libvirt) InterfaceCreate(Iface Interface, Flags uint32) (err error) {
+	var buf []byte
+
+	args := InterfaceCreateArgs {
+		Iface: Iface,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(133, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// InterfaceDestroy is the go wrapper for REMOTE_PROC_INTERFACE_DESTROY.
+func (l *Libvirt) InterfaceDestroy(Iface Interface, Flags uint32) (err error) {
+	var buf []byte
+
+	args := InterfaceDestroyArgs {
+		Iface: Iface,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(134, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectDomainXMLFromNative is the go wrapper for REMOTE_PROC_CONNECT_DOMAIN_XML_FROM_NATIVE.
+func (l *Libvirt) ConnectDomainXMLFromNative(NativeFormat string, NativeConfig string, Flags uint32) (rDomainXML string, err error) {
+	var buf []byte
+
+	args := ConnectDomainXMLFromNativeArgs {
+		NativeFormat: NativeFormat,
+		NativeConfig: NativeConfig,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(135, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// DomainXML: string
+	_, err = dec.Decode(&rDomainXML)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectDomainXMLToNative is the go wrapper for REMOTE_PROC_CONNECT_DOMAIN_XML_TO_NATIVE.
+func (l *Libvirt) ConnectDomainXMLToNative(NativeFormat string, DomainXML string, Flags uint32) (rNativeConfig string, err error) {
+	var buf []byte
+
+	args := ConnectDomainXMLToNativeArgs {
+		NativeFormat: NativeFormat,
+		DomainXML: DomainXML,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(136, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// NativeConfig: string
+	_, err = dec.Decode(&rNativeConfig)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectNumOfDefinedInterfaces is the go wrapper for REMOTE_PROC_CONNECT_NUM_OF_DEFINED_INTERFACES.
+func (l *Libvirt) ConnectNumOfDefinedInterfaces() (rNum int32, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(137, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Num: int32
+	_, err = dec.Decode(&rNum)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectListDefinedInterfaces is the go wrapper for REMOTE_PROC_CONNECT_LIST_DEFINED_INTERFACES.
+func (l *Libvirt) ConnectListDefinedInterfaces(Maxnames int32) (rNames []string, err error) {
+	var buf []byte
+
+	args := ConnectListDefinedInterfacesArgs {
+		Maxnames: Maxnames,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(138, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Names: []string
+	_, err = dec.Decode(&rNames)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectNumOfSecrets is the go wrapper for REMOTE_PROC_CONNECT_NUM_OF_SECRETS.
+func (l *Libvirt) ConnectNumOfSecrets() (rNum int32, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(139, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Num: int32
+	_, err = dec.Decode(&rNum)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectListSecrets is the go wrapper for REMOTE_PROC_CONNECT_LIST_SECRETS.
+func (l *Libvirt) ConnectListSecrets(Maxuuids int32) (rUuids []string, err error) {
+	var buf []byte
+
+	args := ConnectListSecretsArgs {
+		Maxuuids: Maxuuids,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(140, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Uuids: []string
+	_, err = dec.Decode(&rUuids)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// SecretLookupByUUID is the go wrapper for REMOTE_PROC_SECRET_LOOKUP_BY_UUID.
+func (l *Libvirt) SecretLookupByUUID(UUID UUID) (rOptSecret Secret, err error) {
+	var buf []byte
+
+	args := SecretLookupByUUIDArgs {
+		UUID: UUID,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(141, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// OptSecret: Secret
+	_, err = dec.Decode(&rOptSecret)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// SecretDefineXML is the go wrapper for REMOTE_PROC_SECRET_DEFINE_XML.
+func (l *Libvirt) SecretDefineXML(XML string, Flags uint32) (rOptSecret Secret, err error) {
+	var buf []byte
+
+	args := SecretDefineXMLArgs {
+		XML: XML,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(142, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// OptSecret: Secret
+	_, err = dec.Decode(&rOptSecret)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// SecretGetXMLDesc is the go wrapper for REMOTE_PROC_SECRET_GET_XML_DESC.
+func (l *Libvirt) SecretGetXMLDesc(OptSecret Secret, Flags uint32) (rXML string, err error) {
+	var buf []byte
+
+	args := SecretGetXMLDescArgs {
+		OptSecret: OptSecret,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(143, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// XML: string
+	_, err = dec.Decode(&rXML)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// SecretSetValue is the go wrapper for REMOTE_PROC_SECRET_SET_VALUE.
+func (l *Libvirt) SecretSetValue(OptSecret Secret, Value []byte, Flags uint32) (err error) {
+	var buf []byte
+
+	args := SecretSetValueArgs {
+		OptSecret: OptSecret,
+		Value: Value,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(144, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// SecretGetValue is the go wrapper for REMOTE_PROC_SECRET_GET_VALUE.
+func (l *Libvirt) SecretGetValue(OptSecret Secret, Flags uint32) (rValue []byte, err error) {
+	var buf []byte
+
+	args := SecretGetValueArgs {
+		OptSecret: OptSecret,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(145, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Value: []byte
+	_, err = dec.Decode(&rValue)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// SecretUndefine is the go wrapper for REMOTE_PROC_SECRET_UNDEFINE.
+func (l *Libvirt) SecretUndefine(OptSecret Secret) (err error) {
+	var buf []byte
+
+	args := SecretUndefineArgs {
+		OptSecret: OptSecret,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(146, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// SecretLookupByUsage is the go wrapper for REMOTE_PROC_SECRET_LOOKUP_BY_USAGE.
+func (l *Libvirt) SecretLookupByUsage(UsageType int32, UsageID string) (rOptSecret Secret, err error) {
+	var buf []byte
+
+	args := SecretLookupByUsageArgs {
+		UsageType: UsageType,
+		UsageID: UsageID,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(147, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// OptSecret: Secret
+	_, err = dec.Decode(&rOptSecret)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigratePrepareTunnel is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL.
+func (l *Libvirt) DomainMigratePrepareTunnel(Flags uint64, outStream io.Reader, Dname OptString, Resource uint64, DomXML string) (err error) {
+	var buf []byte
+
+	args := DomainMigratePrepareTunnelArgs {
+		Flags: Flags,
+		Dname: Dname,
+		Resource: Resource,
+		DomXML: DomXML,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(148, constants.Program, buf, outStream, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectIsSecure is the go wrapper for REMOTE_PROC_CONNECT_IS_SECURE.
+func (l *Libvirt) ConnectIsSecure() (rSecure int32, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(149, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Secure: int32
+	_, err = dec.Decode(&rSecure)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainIsActive is the go wrapper for REMOTE_PROC_DOMAIN_IS_ACTIVE.
+func (l *Libvirt) DomainIsActive(Dom Domain) (rActive int32, err error) {
+	var buf []byte
+
+	args := DomainIsActiveArgs {
+		Dom: Dom,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(150, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Active: int32
+	_, err = dec.Decode(&rActive)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainIsPersistent is the go wrapper for REMOTE_PROC_DOMAIN_IS_PERSISTENT.
+func (l *Libvirt) DomainIsPersistent(Dom Domain) (rPersistent int32, err error) {
+	var buf []byte
+
+	args := DomainIsPersistentArgs {
+		Dom: Dom,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(151, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Persistent: int32
+	_, err = dec.Decode(&rPersistent)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkIsActive is the go wrapper for REMOTE_PROC_NETWORK_IS_ACTIVE.
+func (l *Libvirt) NetworkIsActive(Net Network) (rActive int32, err error) {
+	var buf []byte
+
+	args := NetworkIsActiveArgs {
+		Net: Net,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(152, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Active: int32
+	_, err = dec.Decode(&rActive)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkIsPersistent is the go wrapper for REMOTE_PROC_NETWORK_IS_PERSISTENT.
+func (l *Libvirt) NetworkIsPersistent(Net Network) (rPersistent int32, err error) {
+	var buf []byte
+
+	args := NetworkIsPersistentArgs {
+		Net: Net,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(153, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Persistent: int32
+	_, err = dec.Decode(&rPersistent)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolIsActive is the go wrapper for REMOTE_PROC_STORAGE_POOL_IS_ACTIVE.
+func (l *Libvirt) StoragePoolIsActive(Pool StoragePool) (rActive int32, err error) {
+	var buf []byte
+
+	args := StoragePoolIsActiveArgs {
+		Pool: Pool,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(154, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Active: int32
+	_, err = dec.Decode(&rActive)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolIsPersistent is the go wrapper for REMOTE_PROC_STORAGE_POOL_IS_PERSISTENT.
+func (l *Libvirt) StoragePoolIsPersistent(Pool StoragePool) (rPersistent int32, err error) {
+	var buf []byte
+
+	args := StoragePoolIsPersistentArgs {
+		Pool: Pool,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(155, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Persistent: int32
+	_, err = dec.Decode(&rPersistent)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// InterfaceIsActive is the go wrapper for REMOTE_PROC_INTERFACE_IS_ACTIVE.
+func (l *Libvirt) InterfaceIsActive(Iface Interface) (rActive int32, err error) {
+	var buf []byte
+
+	args := InterfaceIsActiveArgs {
+		Iface: Iface,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(156, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Active: int32
+	_, err = dec.Decode(&rActive)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectGetLibVersion is the go wrapper for REMOTE_PROC_CONNECT_GET_LIB_VERSION.
+func (l *Libvirt) ConnectGetLibVersion() (rLibVer uint64, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(157, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// LibVer: uint64
+	_, err = dec.Decode(&rLibVer)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectCompareCPU is the go wrapper for REMOTE_PROC_CONNECT_COMPARE_CPU.
+func (l *Libvirt) ConnectCompareCPU(XML string, Flags ConnectCompareCPUFlags) (rResult int32, err error) {
+	var buf []byte
+
+	args := ConnectCompareCPUArgs {
+		XML: XML,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(158, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Result: int32
+	_, err = dec.Decode(&rResult)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMemoryStats is the go wrapper for REMOTE_PROC_DOMAIN_MEMORY_STATS.
+func (l *Libvirt) DomainMemoryStats(Dom Domain, MaxStats uint32, Flags uint32) (rStats []DomainMemoryStat, err error) {
+	var buf []byte
+
+	args := DomainMemoryStatsArgs {
+		Dom: Dom,
+		MaxStats: MaxStats,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(159, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Stats: []DomainMemoryStat
+	_, err = dec.Decode(&rStats)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainAttachDeviceFlags is the go wrapper for REMOTE_PROC_DOMAIN_ATTACH_DEVICE_FLAGS.
+func (l *Libvirt) DomainAttachDeviceFlags(Dom Domain, XML string, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainAttachDeviceFlagsArgs {
+		Dom: Dom,
+		XML: XML,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(160, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainDetachDeviceFlags is the go wrapper for REMOTE_PROC_DOMAIN_DETACH_DEVICE_FLAGS.
+func (l *Libvirt) DomainDetachDeviceFlags(Dom Domain, XML string, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainDetachDeviceFlagsArgs {
+		Dom: Dom,
+		XML: XML,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(161, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectBaselineCPU is the go wrapper for REMOTE_PROC_CONNECT_BASELINE_CPU.
+func (l *Libvirt) ConnectBaselineCPU(XMLCPUs []string, Flags ConnectBaselineCPUFlags) (rCPU string, err error) {
+	var buf []byte
+
+	args := ConnectBaselineCPUArgs {
+		XMLCPUs: XMLCPUs,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(162, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// CPU: string
+	_, err = dec.Decode(&rCPU)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetJobInfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_JOB_INFO.
+func (l *Libvirt) DomainGetJobInfo(Dom Domain) (rType int32, rTimeElapsed uint64, rTimeRemaining uint64, rDataTotal uint64, rDataProcessed uint64, rDataRemaining uint64, rMemTotal uint64, rMemProcessed uint64, rMemRemaining uint64, rFileTotal uint64, rFileProcessed uint64, rFileRemaining uint64, err error) {
+	var buf []byte
+
+	args := DomainGetJobInfoArgs {
+		Dom: Dom,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(163, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Type: int32
+	_, err = dec.Decode(&rType)
+	if err != nil {
+		return
+	}
+	// TimeElapsed: uint64
+	_, err = dec.Decode(&rTimeElapsed)
+	if err != nil {
+		return
+	}
+	// TimeRemaining: uint64
+	_, err = dec.Decode(&rTimeRemaining)
+	if err != nil {
+		return
+	}
+	// DataTotal: uint64
+	_, err = dec.Decode(&rDataTotal)
+	if err != nil {
+		return
+	}
+	// DataProcessed: uint64
+	_, err = dec.Decode(&rDataProcessed)
+	if err != nil {
+		return
+	}
+	// DataRemaining: uint64
+	_, err = dec.Decode(&rDataRemaining)
+	if err != nil {
+		return
+	}
+	// MemTotal: uint64
+	_, err = dec.Decode(&rMemTotal)
+	if err != nil {
+		return
+	}
+	// MemProcessed: uint64
+	_, err = dec.Decode(&rMemProcessed)
+	if err != nil {
+		return
+	}
+	// MemRemaining: uint64
+	_, err = dec.Decode(&rMemRemaining)
+	if err != nil {
+		return
+	}
+	// FileTotal: uint64
+	_, err = dec.Decode(&rFileTotal)
+	if err != nil {
+		return
+	}
+	// FileProcessed: uint64
+	_, err = dec.Decode(&rFileProcessed)
+	if err != nil {
+		return
+	}
+	// FileRemaining: uint64
+	_, err = dec.Decode(&rFileRemaining)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainAbortJob is the go wrapper for REMOTE_PROC_DOMAIN_ABORT_JOB.
+func (l *Libvirt) DomainAbortJob(Dom Domain) (err error) {
+	var buf []byte
+
+	args := DomainAbortJobArgs {
+		Dom: Dom,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(164, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StorageVolWipe is the go wrapper for REMOTE_PROC_STORAGE_VOL_WIPE.
+func (l *Libvirt) StorageVolWipe(Vol StorageVol, Flags uint32) (err error) {
+	var buf []byte
+
+	args := StorageVolWipeArgs {
+		Vol: Vol,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(165, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigrateSetMaxDowntime is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_SET_MAX_DOWNTIME.
+func (l *Libvirt) DomainMigrateSetMaxDowntime(Dom Domain, Downtime uint64, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainMigrateSetMaxDowntimeArgs {
+		Dom: Dom,
+		Downtime: Downtime,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(166, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectDomainEventRegisterAny is the go wrapper for REMOTE_PROC_CONNECT_DOMAIN_EVENT_REGISTER_ANY.
+func (l *Libvirt) ConnectDomainEventRegisterAny(EventID int32) (err error) {
+	var buf []byte
+
+	args := ConnectDomainEventRegisterAnyArgs {
+		EventID: EventID,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(167, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectDomainEventDeregisterAny is the go wrapper for REMOTE_PROC_CONNECT_DOMAIN_EVENT_DEREGISTER_ANY.
+func (l *Libvirt) ConnectDomainEventDeregisterAny(EventID int32) (err error) {
+	var buf []byte
+
+	args := ConnectDomainEventDeregisterAnyArgs {
+		EventID: EventID,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(168, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventReboot is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_REBOOT.
+func (l *Libvirt) DomainEventReboot() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(169, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventRtcChange is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE.
+func (l *Libvirt) DomainEventRtcChange() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(170, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventWatchdog is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_WATCHDOG.
+func (l *Libvirt) DomainEventWatchdog() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(171, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventIOError is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_IO_ERROR.
+func (l *Libvirt) DomainEventIOError() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(172, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventGraphics is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_GRAPHICS.
+func (l *Libvirt) DomainEventGraphics() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(173, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainUpdateDeviceFlags is the go wrapper for REMOTE_PROC_DOMAIN_UPDATE_DEVICE_FLAGS.
+func (l *Libvirt) DomainUpdateDeviceFlags(Dom Domain, XML string, Flags DomainDeviceModifyFlags) (err error) {
+	var buf []byte
+
+	args := DomainUpdateDeviceFlagsArgs {
+		Dom: Dom,
+		XML: XML,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(174, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NwfilterLookupByName is the go wrapper for REMOTE_PROC_NWFILTER_LOOKUP_BY_NAME.
+func (l *Libvirt) NwfilterLookupByName(Name string) (rOptNwfilter Nwfilter, err error) {
+	var buf []byte
+
+	args := NwfilterLookupByNameArgs {
+		Name: Name,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(175, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// OptNwfilter: Nwfilter
+	_, err = dec.Decode(&rOptNwfilter)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NwfilterLookupByUUID is the go wrapper for REMOTE_PROC_NWFILTER_LOOKUP_BY_UUID.
+func (l *Libvirt) NwfilterLookupByUUID(UUID UUID) (rOptNwfilter Nwfilter, err error) {
+	var buf []byte
+
+	args := NwfilterLookupByUUIDArgs {
+		UUID: UUID,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(176, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// OptNwfilter: Nwfilter
+	_, err = dec.Decode(&rOptNwfilter)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NwfilterGetXMLDesc is the go wrapper for REMOTE_PROC_NWFILTER_GET_XML_DESC.
+func (l *Libvirt) NwfilterGetXMLDesc(OptNwfilter Nwfilter, Flags uint32) (rXML string, err error) {
+	var buf []byte
+
+	args := NwfilterGetXMLDescArgs {
+		OptNwfilter: OptNwfilter,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(177, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// XML: string
+	_, err = dec.Decode(&rXML)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectNumOfNwfilters is the go wrapper for REMOTE_PROC_CONNECT_NUM_OF_NWFILTERS.
+func (l *Libvirt) ConnectNumOfNwfilters() (rNum int32, err error) {
+	var buf []byte
+
+	var r response
+	r, err = l.requestStream(178, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Num: int32
+	_, err = dec.Decode(&rNum)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectListNwfilters is the go wrapper for REMOTE_PROC_CONNECT_LIST_NWFILTERS.
+func (l *Libvirt) ConnectListNwfilters(Maxnames int32) (rNames []string, err error) {
+	var buf []byte
+
+	args := ConnectListNwfiltersArgs {
+		Maxnames: Maxnames,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(179, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Names: []string
+	_, err = dec.Decode(&rNames)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NwfilterDefineXML is the go wrapper for REMOTE_PROC_NWFILTER_DEFINE_XML.
+func (l *Libvirt) NwfilterDefineXML(XML string) (rOptNwfilter Nwfilter, err error) {
+	var buf []byte
+
+	args := NwfilterDefineXMLArgs {
+		XML: XML,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(180, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// OptNwfilter: Nwfilter
+	_, err = dec.Decode(&rOptNwfilter)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NwfilterUndefine is the go wrapper for REMOTE_PROC_NWFILTER_UNDEFINE.
+func (l *Libvirt) NwfilterUndefine(OptNwfilter Nwfilter) (err error) {
+	var buf []byte
+
+	args := NwfilterUndefineArgs {
+		OptNwfilter: OptNwfilter,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(181, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainManagedSave is the go wrapper for REMOTE_PROC_DOMAIN_MANAGED_SAVE.
+func (l *Libvirt) DomainManagedSave(Dom Domain, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainManagedSaveArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(182, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainHasManagedSaveImage is the go wrapper for REMOTE_PROC_DOMAIN_HAS_MANAGED_SAVE_IMAGE.
+func (l *Libvirt) DomainHasManagedSaveImage(Dom Domain, Flags uint32) (rResult int32, err error) {
+	var buf []byte
+
+	args := DomainHasManagedSaveImageArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(183, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Result: int32
+	_, err = dec.Decode(&rResult)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainManagedSaveRemove is the go wrapper for REMOTE_PROC_DOMAIN_MANAGED_SAVE_REMOVE.
+func (l *Libvirt) DomainManagedSaveRemove(Dom Domain, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainManagedSaveRemoveArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(184, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSnapshotCreateXML is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_CREATE_XML.
+func (l *Libvirt) DomainSnapshotCreateXML(Dom Domain, XMLDesc string, Flags uint32) (rSnap DomainSnapshot, err error) {
+	var buf []byte
+
+	args := DomainSnapshotCreateXMLArgs {
+		Dom: Dom,
+		XMLDesc: XMLDesc,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(185, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Snap: DomainSnapshot
+	_, err = dec.Decode(&rSnap)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSnapshotGetXMLDesc is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_GET_XML_DESC.
+func (l *Libvirt) DomainSnapshotGetXMLDesc(Snap DomainSnapshot, Flags uint32) (rXML string, err error) {
+	var buf []byte
+
+	args := DomainSnapshotGetXMLDescArgs {
+		Snap: Snap,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(186, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// XML: string
+	_, err = dec.Decode(&rXML)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSnapshotNum is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_NUM.
+func (l *Libvirt) DomainSnapshotNum(Dom Domain, Flags uint32) (rNum int32, err error) {
+	var buf []byte
+
+	args := DomainSnapshotNumArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(187, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Num: int32
+	_, err = dec.Decode(&rNum)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSnapshotListNames is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_NAMES.
+func (l *Libvirt) DomainSnapshotListNames(Dom Domain, Maxnames int32, Flags uint32) (rNames []string, err error) {
+	var buf []byte
+
+	args := DomainSnapshotListNamesArgs {
+		Dom: Dom,
+		Maxnames: Maxnames,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(188, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Names: []string
+	_, err = dec.Decode(&rNames)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSnapshotLookupByName is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_LOOKUP_BY_NAME.
+func (l *Libvirt) DomainSnapshotLookupByName(Dom Domain, Name string, Flags uint32) (rSnap DomainSnapshot, err error) {
+	var buf []byte
+
+	args := DomainSnapshotLookupByNameArgs {
+		Dom: Dom,
+		Name: Name,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(189, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Snap: DomainSnapshot
+	_, err = dec.Decode(&rSnap)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainHasCurrentSnapshot is the go wrapper for REMOTE_PROC_DOMAIN_HAS_CURRENT_SNAPSHOT.
+func (l *Libvirt) DomainHasCurrentSnapshot(Dom Domain, Flags uint32) (rResult int32, err error) {
+	var buf []byte
+
+	args := DomainHasCurrentSnapshotArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(190, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Result: int32
+	_, err = dec.Decode(&rResult)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSnapshotCurrent is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_CURRENT.
+func (l *Libvirt) DomainSnapshotCurrent(Dom Domain, Flags uint32) (rSnap DomainSnapshot, err error) {
+	var buf []byte
+
+	args := DomainSnapshotCurrentArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(191, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Snap: DomainSnapshot
+	_, err = dec.Decode(&rSnap)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainRevertToSnapshot is the go wrapper for REMOTE_PROC_DOMAIN_REVERT_TO_SNAPSHOT.
+func (l *Libvirt) DomainRevertToSnapshot(Snap DomainSnapshot, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainRevertToSnapshotArgs {
+		Snap: Snap,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(192, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSnapshotDelete is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_DELETE.
+func (l *Libvirt) DomainSnapshotDelete(Snap DomainSnapshot, Flags DomainSnapshotDeleteFlags) (err error) {
+	var buf []byte
+
+	args := DomainSnapshotDeleteArgs {
+		Snap: Snap,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(193, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetBlockInfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_BLOCK_INFO.
+func (l *Libvirt) DomainGetBlockInfo(Dom Domain, Path string, Flags uint32) (rAllocation uint64, rCapacity uint64, rPhysical uint64, err error) {
+	var buf []byte
+
+	args := DomainGetBlockInfoArgs {
+		Dom: Dom,
+		Path: Path,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(194, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Allocation: uint64
+	_, err = dec.Decode(&rAllocation)
+	if err != nil {
+		return
+	}
+	// Capacity: uint64
+	_, err = dec.Decode(&rCapacity)
+	if err != nil {
+		return
+	}
+	// Physical: uint64
+	_, err = dec.Decode(&rPhysical)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventIOErrorReason is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_IO_ERROR_REASON.
+func (l *Libvirt) DomainEventIOErrorReason() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(195, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainCreateWithFlags is the go wrapper for REMOTE_PROC_DOMAIN_CREATE_WITH_FLAGS.
+func (l *Libvirt) DomainCreateWithFlags(Dom Domain, Flags uint32) (rDom Domain, err error) {
+	var buf []byte
+
+	args := DomainCreateWithFlagsArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(196, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Dom: Domain
+	_, err = dec.Decode(&rDom)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetMemoryParameters is the go wrapper for REMOTE_PROC_DOMAIN_SET_MEMORY_PARAMETERS.
+func (l *Libvirt) DomainSetMemoryParameters(Dom Domain, Params []TypedParam, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainSetMemoryParametersArgs {
+		Dom: Dom,
+		Params: Params,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(197, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetMemoryParameters is the go wrapper for REMOTE_PROC_DOMAIN_GET_MEMORY_PARAMETERS.
+func (l *Libvirt) DomainGetMemoryParameters(Dom Domain, Nparams int32, Flags uint32) (rParams []TypedParam, rNparams int32, err error) {
+	var buf []byte
+
+	args := DomainGetMemoryParametersArgs {
+		Dom: Dom,
+		Nparams: Nparams,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(198, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Params: []TypedParam
+	_, err = dec.Decode(&rParams)
+	if err != nil {
+		return
+	}
+	// Nparams: int32
+	_, err = dec.Decode(&rNparams)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetVcpusFlags is the go wrapper for REMOTE_PROC_DOMAIN_SET_VCPUS_FLAGS.
+func (l *Libvirt) DomainSetVcpusFlags(Dom Domain, Nvcpus uint32, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainSetVcpusFlagsArgs {
+		Dom: Dom,
+		Nvcpus: Nvcpus,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(199, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetVcpusFlags is the go wrapper for REMOTE_PROC_DOMAIN_GET_VCPUS_FLAGS.
+func (l *Libvirt) DomainGetVcpusFlags(Dom Domain, Flags uint32) (rNum int32, err error) {
+	var buf []byte
+
+	args := DomainGetVcpusFlagsArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(200, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Num: int32
+	_, err = dec.Decode(&rNum)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainOpenConsole is the go wrapper for REMOTE_PROC_DOMAIN_OPEN_CONSOLE.
+func (l *Libvirt) DomainOpenConsole(Dom Domain, DevName OptString, inStream io.Writer, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainOpenConsoleArgs {
+		Dom: Dom,
+		DevName: DevName,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(201, constants.Program, buf, nil, inStream)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainIsUpdated is the go wrapper for REMOTE_PROC_DOMAIN_IS_UPDATED.
+func (l *Libvirt) DomainIsUpdated(Dom Domain) (rUpdated int32, err error) {
+	var buf []byte
+
+	args := DomainIsUpdatedArgs {
+		Dom: Dom,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(202, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Updated: int32
+	_, err = dec.Decode(&rUpdated)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectGetSysinfo is the go wrapper for REMOTE_PROC_CONNECT_GET_SYSINFO.
+func (l *Libvirt) ConnectGetSysinfo(Flags uint32) (rSysinfo string, err error) {
+	var buf []byte
+
+	args := ConnectGetSysinfoArgs {
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(203, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Sysinfo: string
+	_, err = dec.Decode(&rSysinfo)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetMemoryFlags is the go wrapper for REMOTE_PROC_DOMAIN_SET_MEMORY_FLAGS.
+func (l *Libvirt) DomainSetMemoryFlags(Dom Domain, Memory uint64, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainSetMemoryFlagsArgs {
+		Dom: Dom,
+		Memory: Memory,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(204, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetBlkioParameters is the go wrapper for REMOTE_PROC_DOMAIN_SET_BLKIO_PARAMETERS.
+func (l *Libvirt) DomainSetBlkioParameters(Dom Domain, Params []TypedParam, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainSetBlkioParametersArgs {
+		Dom: Dom,
+		Params: Params,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(205, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetBlkioParameters is the go wrapper for REMOTE_PROC_DOMAIN_GET_BLKIO_PARAMETERS.
+func (l *Libvirt) DomainGetBlkioParameters(Dom Domain, Nparams int32, Flags uint32) (rParams []TypedParam, rNparams int32, err error) {
+	var buf []byte
+
+	args := DomainGetBlkioParametersArgs {
+		Dom: Dom,
+		Nparams: Nparams,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(206, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Params: []TypedParam
+	_, err = dec.Decode(&rParams)
+	if err != nil {
+		return
+	}
+	// Nparams: int32
+	_, err = dec.Decode(&rNparams)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigrateSetMaxSpeed is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_SET_MAX_SPEED.
+func (l *Libvirt) DomainMigrateSetMaxSpeed(Dom Domain, Bandwidth uint64, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainMigrateSetMaxSpeedArgs {
+		Dom: Dom,
+		Bandwidth: Bandwidth,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(207, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StorageVolUpload is the go wrapper for REMOTE_PROC_STORAGE_VOL_UPLOAD.
+func (l *Libvirt) StorageVolUpload(Vol StorageVol, outStream io.Reader, Offset uint64, Length uint64, Flags StorageVolUploadFlags) (err error) {
+	var buf []byte
+
+	args := StorageVolUploadArgs {
+		Vol: Vol,
+		Offset: Offset,
+		Length: Length,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(208, constants.Program, buf, outStream, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StorageVolDownload is the go wrapper for REMOTE_PROC_STORAGE_VOL_DOWNLOAD.
+func (l *Libvirt) StorageVolDownload(Vol StorageVol, inStream io.Writer, Offset uint64, Length uint64, Flags StorageVolDownloadFlags) (err error) {
+	var buf []byte
+
+	args := StorageVolDownloadArgs {
+		Vol: Vol,
+		Offset: Offset,
+		Length: Length,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(209, constants.Program, buf, nil, inStream)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainInjectNmi is the go wrapper for REMOTE_PROC_DOMAIN_INJECT_NMI.
+func (l *Libvirt) DomainInjectNmi(Dom Domain, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainInjectNmiArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(210, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainScreenshot is the go wrapper for REMOTE_PROC_DOMAIN_SCREENSHOT.
+func (l *Libvirt) DomainScreenshot(Dom Domain, inStream io.Writer, Screen uint32, Flags uint32) (rMime OptString, err error) {
+	var buf []byte
+
+	args := DomainScreenshotArgs {
+		Dom: Dom,
+		Screen: Screen,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(211, constants.Program, buf, nil, inStream)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Mime: OptString
+	_, err = dec.Decode(&rMime)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetState is the go wrapper for REMOTE_PROC_DOMAIN_GET_STATE.
+func (l *Libvirt) DomainGetState(Dom Domain, Flags uint32) (rState int32, rReason int32, err error) {
+	var buf []byte
+
+	args := DomainGetStateArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(212, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// State: int32
+	_, err = dec.Decode(&rState)
+	if err != nil {
+		return
+	}
+	// Reason: int32
+	_, err = dec.Decode(&rReason)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigrateBegin3 is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_BEGIN3.
+func (l *Libvirt) DomainMigrateBegin3(Dom Domain, Xmlin OptString, Flags uint64, Dname OptString, Resource uint64) (rCookieOut []byte, rXML string, err error) {
+	var buf []byte
+
+	args := DomainMigrateBegin3Args {
+		Dom: Dom,
+		Xmlin: Xmlin,
+		Flags: Flags,
+		Dname: Dname,
+		Resource: Resource,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(213, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// CookieOut: []byte
+	_, err = dec.Decode(&rCookieOut)
+	if err != nil {
+		return
+	}
+	// XML: string
+	_, err = dec.Decode(&rXML)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigratePrepare3 is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_PREPARE3.
+func (l *Libvirt) DomainMigratePrepare3(CookieIn []byte, UriIn OptString, Flags uint64, Dname OptString, Resource uint64, DomXML string) (rCookieOut []byte, rUriOut OptString, err error) {
+	var buf []byte
+
+	args := DomainMigratePrepare3Args {
+		CookieIn: CookieIn,
+		UriIn: UriIn,
+		Flags: Flags,
+		Dname: Dname,
+		Resource: Resource,
+		DomXML: DomXML,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(214, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// CookieOut: []byte
+	_, err = dec.Decode(&rCookieOut)
+	if err != nil {
+		return
+	}
+	// UriOut: OptString
+	_, err = dec.Decode(&rUriOut)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigratePrepareTunnel3 is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL3.
+func (l *Libvirt) DomainMigratePrepareTunnel3(CookieIn []byte, outStream io.Reader, Flags uint64, Dname OptString, Resource uint64, DomXML string) (rCookieOut []byte, err error) {
+	var buf []byte
+
+	args := DomainMigratePrepareTunnel3Args {
+		CookieIn: CookieIn,
+		Flags: Flags,
+		Dname: Dname,
+		Resource: Resource,
+		DomXML: DomXML,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(215, constants.Program, buf, outStream, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// CookieOut: []byte
+	_, err = dec.Decode(&rCookieOut)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigratePerform3 is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_PERFORM3.
+func (l *Libvirt) DomainMigratePerform3(Dom Domain, Xmlin OptString, CookieIn []byte, Dconnuri OptString, Uri OptString, Flags uint64, Dname OptString, Resource uint64) (rCookieOut []byte, err error) {
+	var buf []byte
+
+	args := DomainMigratePerform3Args {
+		Dom: Dom,
+		Xmlin: Xmlin,
+		CookieIn: CookieIn,
+		Dconnuri: Dconnuri,
+		Uri: Uri,
+		Flags: Flags,
+		Dname: Dname,
+		Resource: Resource,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(216, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// CookieOut: []byte
+	_, err = dec.Decode(&rCookieOut)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigrateFinish3 is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_FINISH3.
+func (l *Libvirt) DomainMigrateFinish3(Dname string, CookieIn []byte, Dconnuri OptString, Uri OptString, Flags uint64, Cancelled int32) (rDom Domain, rCookieOut []byte, err error) {
+	var buf []byte
+
+	args := DomainMigrateFinish3Args {
+		Dname: Dname,
+		CookieIn: CookieIn,
+		Dconnuri: Dconnuri,
+		Uri: Uri,
+		Flags: Flags,
+		Cancelled: Cancelled,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(217, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Dom: Domain
+	_, err = dec.Decode(&rDom)
+	if err != nil {
+		return
+	}
+	// CookieOut: []byte
+	_, err = dec.Decode(&rCookieOut)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigrateConfirm3 is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_CONFIRM3.
+func (l *Libvirt) DomainMigrateConfirm3(Dom Domain, CookieIn []byte, Flags uint64, Cancelled int32) (err error) {
+	var buf []byte
+
+	args := DomainMigrateConfirm3Args {
+		Dom: Dom,
+		CookieIn: CookieIn,
+		Flags: Flags,
+		Cancelled: Cancelled,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(218, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetSchedulerParametersFlags is the go wrapper for REMOTE_PROC_DOMAIN_SET_SCHEDULER_PARAMETERS_FLAGS.
+func (l *Libvirt) DomainSetSchedulerParametersFlags(Dom Domain, Params []TypedParam, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainSetSchedulerParametersFlagsArgs {
+		Dom: Dom,
+		Params: Params,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(219, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// InterfaceChangeBegin is the go wrapper for REMOTE_PROC_INTERFACE_CHANGE_BEGIN.
+func (l *Libvirt) InterfaceChangeBegin(Flags uint32) (err error) {
+	var buf []byte
+
+	args := InterfaceChangeBeginArgs {
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(220, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// InterfaceChangeCommit is the go wrapper for REMOTE_PROC_INTERFACE_CHANGE_COMMIT.
+func (l *Libvirt) InterfaceChangeCommit(Flags uint32) (err error) {
+	var buf []byte
+
+	args := InterfaceChangeCommitArgs {
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(221, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// InterfaceChangeRollback is the go wrapper for REMOTE_PROC_INTERFACE_CHANGE_ROLLBACK.
+func (l *Libvirt) InterfaceChangeRollback(Flags uint32) (err error) {
+	var buf []byte
+
+	args := InterfaceChangeRollbackArgs {
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(222, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetSchedulerParametersFlags is the go wrapper for REMOTE_PROC_DOMAIN_GET_SCHEDULER_PARAMETERS_FLAGS.
+func (l *Libvirt) DomainGetSchedulerParametersFlags(Dom Domain, Nparams int32, Flags uint32) (rParams []TypedParam, err error) {
+	var buf []byte
+
+	args := DomainGetSchedulerParametersFlagsArgs {
+		Dom: Dom,
+		Nparams: Nparams,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(223, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Params: []TypedParam
+	_, err = dec.Decode(&rParams)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventControlError is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CONTROL_ERROR.
+func (l *Libvirt) DomainEventControlError() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(224, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainPinVcpuFlags is the go wrapper for REMOTE_PROC_DOMAIN_PIN_VCPU_FLAGS.
+func (l *Libvirt) DomainPinVcpuFlags(Dom Domain, Vcpu uint32, Cpumap []byte, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainPinVcpuFlagsArgs {
+		Dom: Dom,
+		Vcpu: Vcpu,
+		Cpumap: Cpumap,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(225, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSendKey is the go wrapper for REMOTE_PROC_DOMAIN_SEND_KEY.
+func (l *Libvirt) DomainSendKey(Dom Domain, Codeset uint32, Holdtime uint32, Keycodes []uint32, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainSendKeyArgs {
+		Dom: Dom,
+		Codeset: Codeset,
+		Holdtime: Holdtime,
+		Keycodes: Keycodes,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(226, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeGetCPUStats is the go wrapper for REMOTE_PROC_NODE_GET_CPU_STATS.
+func (l *Libvirt) NodeGetCPUStats(CPUNum int32, Nparams int32, Flags uint32) (rParams []NodeGetCPUStats, rNparams int32, err error) {
+	var buf []byte
+
+	args := NodeGetCPUStatsArgs {
+		CPUNum: CPUNum,
+		Nparams: Nparams,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(227, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Params: []NodeGetCPUStats
+	_, err = dec.Decode(&rParams)
+	if err != nil {
+		return
+	}
+	// Nparams: int32
+	_, err = dec.Decode(&rNparams)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeGetMemoryStats is the go wrapper for REMOTE_PROC_NODE_GET_MEMORY_STATS.
+func (l *Libvirt) NodeGetMemoryStats(Nparams int32, CellNum int32, Flags uint32) (rParams []NodeGetMemoryStats, rNparams int32, err error) {
+	var buf []byte
+
+	args := NodeGetMemoryStatsArgs {
+		Nparams: Nparams,
+		CellNum: CellNum,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(228, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Params: []NodeGetMemoryStats
+	_, err = dec.Decode(&rParams)
+	if err != nil {
+		return
+	}
+	// Nparams: int32
+	_, err = dec.Decode(&rNparams)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetControlInfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_CONTROL_INFO.
+func (l *Libvirt) DomainGetControlInfo(Dom Domain, Flags uint32) (rState uint32, rDetails uint32, rStateTime uint64, err error) {
+	var buf []byte
+
+	args := DomainGetControlInfoArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(229, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// State: uint32
+	_, err = dec.Decode(&rState)
+	if err != nil {
+		return
+	}
+	// Details: uint32
+	_, err = dec.Decode(&rDetails)
+	if err != nil {
+		return
+	}
+	// StateTime: uint64
+	_, err = dec.Decode(&rStateTime)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetVcpuPinInfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_VCPU_PIN_INFO.
+func (l *Libvirt) DomainGetVcpuPinInfo(Dom Domain, Ncpumaps int32, Maplen int32, Flags uint32) (rCpumaps []byte, rNum int32, err error) {
+	var buf []byte
+
+	args := DomainGetVcpuPinInfoArgs {
+		Dom: Dom,
+		Ncpumaps: Ncpumaps,
+		Maplen: Maplen,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(230, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Cpumaps: []byte
+	_, err = dec.Decode(&rCpumaps)
+	if err != nil {
+		return
+	}
+	// Num: int32
+	_, err = dec.Decode(&rNum)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainUndefineFlags is the go wrapper for REMOTE_PROC_DOMAIN_UNDEFINE_FLAGS.
+func (l *Libvirt) DomainUndefineFlags(Dom Domain, Flags DomainUndefineFlagsValues) (err error) {
+	var buf []byte
+
+	args := DomainUndefineFlagsArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(231, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSaveFlags is the go wrapper for REMOTE_PROC_DOMAIN_SAVE_FLAGS.
+func (l *Libvirt) DomainSaveFlags(Dom Domain, To string, Dxml OptString, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainSaveFlagsArgs {
+		Dom: Dom,
+		To: To,
+		Dxml: Dxml,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(232, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainRestoreFlags is the go wrapper for REMOTE_PROC_DOMAIN_RESTORE_FLAGS.
+func (l *Libvirt) DomainRestoreFlags(From string, Dxml OptString, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainRestoreFlagsArgs {
+		From: From,
+		Dxml: Dxml,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(233, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainDestroyFlags is the go wrapper for REMOTE_PROC_DOMAIN_DESTROY_FLAGS.
+func (l *Libvirt) DomainDestroyFlags(Dom Domain, Flags DomainDestroyFlagsValues) (err error) {
+	var buf []byte
+
+	args := DomainDestroyFlagsArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(234, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSaveImageGetXMLDesc is the go wrapper for REMOTE_PROC_DOMAIN_SAVE_IMAGE_GET_XML_DESC.
+func (l *Libvirt) DomainSaveImageGetXMLDesc(File string, Flags uint32) (rXML string, err error) {
+	var buf []byte
+
+	args := DomainSaveImageGetXMLDescArgs {
+		File: File,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(235, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// XML: string
+	_, err = dec.Decode(&rXML)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSaveImageDefineXML is the go wrapper for REMOTE_PROC_DOMAIN_SAVE_IMAGE_DEFINE_XML.
+func (l *Libvirt) DomainSaveImageDefineXML(File string, Dxml string, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainSaveImageDefineXMLArgs {
+		File: File,
+		Dxml: Dxml,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(236, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainBlockJobAbort is the go wrapper for REMOTE_PROC_DOMAIN_BLOCK_JOB_ABORT.
+func (l *Libvirt) DomainBlockJobAbort(Dom Domain, Path string, Flags DomainBlockJobAbortFlags) (err error) {
+	var buf []byte
+
+	args := DomainBlockJobAbortArgs {
+		Dom: Dom,
+		Path: Path,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(237, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetBlockJobInfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_BLOCK_JOB_INFO.
+func (l *Libvirt) DomainGetBlockJobInfo(Dom Domain, Path string, Flags uint32) (rFound int32, rType int32, rBandwidth uint64, rCur uint64, rEnd uint64, err error) {
+	var buf []byte
+
+	args := DomainGetBlockJobInfoArgs {
+		Dom: Dom,
+		Path: Path,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(238, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Found: int32
+	_, err = dec.Decode(&rFound)
+	if err != nil {
+		return
+	}
+	// Type: int32
+	_, err = dec.Decode(&rType)
+	if err != nil {
+		return
+	}
+	// Bandwidth: uint64
+	_, err = dec.Decode(&rBandwidth)
+	if err != nil {
+		return
+	}
+	// Cur: uint64
+	_, err = dec.Decode(&rCur)
+	if err != nil {
+		return
+	}
+	// End: uint64
+	_, err = dec.Decode(&rEnd)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainBlockJobSetSpeed is the go wrapper for REMOTE_PROC_DOMAIN_BLOCK_JOB_SET_SPEED.
+func (l *Libvirt) DomainBlockJobSetSpeed(Dom Domain, Path string, Bandwidth uint64, Flags DomainBlockJobSetSpeedFlags) (err error) {
+	var buf []byte
+
+	args := DomainBlockJobSetSpeedArgs {
+		Dom: Dom,
+		Path: Path,
+		Bandwidth: Bandwidth,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(239, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainBlockPull is the go wrapper for REMOTE_PROC_DOMAIN_BLOCK_PULL.
+func (l *Libvirt) DomainBlockPull(Dom Domain, Path string, Bandwidth uint64, Flags DomainBlockPullFlags) (err error) {
+	var buf []byte
+
+	args := DomainBlockPullArgs {
+		Dom: Dom,
+		Path: Path,
+		Bandwidth: Bandwidth,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(240, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventBlockJob is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_BLOCK_JOB.
+func (l *Libvirt) DomainEventBlockJob() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(241, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigrateGetMaxSpeed is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_GET_MAX_SPEED.
+func (l *Libvirt) DomainMigrateGetMaxSpeed(Dom Domain, Flags uint32) (rBandwidth uint64, err error) {
+	var buf []byte
+
+	args := DomainMigrateGetMaxSpeedArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(242, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Bandwidth: uint64
+	_, err = dec.Decode(&rBandwidth)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainBlockStatsFlags is the go wrapper for REMOTE_PROC_DOMAIN_BLOCK_STATS_FLAGS.
+func (l *Libvirt) DomainBlockStatsFlags(Dom Domain, Path string, Nparams int32, Flags uint32) (rParams []TypedParam, rNparams int32, err error) {
+	var buf []byte
+
+	args := DomainBlockStatsFlagsArgs {
+		Dom: Dom,
+		Path: Path,
+		Nparams: Nparams,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(243, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Params: []TypedParam
+	_, err = dec.Decode(&rParams)
+	if err != nil {
+		return
+	}
+	// Nparams: int32
+	_, err = dec.Decode(&rNparams)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSnapshotGetParent is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_GET_PARENT.
+func (l *Libvirt) DomainSnapshotGetParent(Snap DomainSnapshot, Flags uint32) (rSnap DomainSnapshot, err error) {
+	var buf []byte
+
+	args := DomainSnapshotGetParentArgs {
+		Snap: Snap,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(244, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Snap: DomainSnapshot
+	_, err = dec.Decode(&rSnap)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainReset is the go wrapper for REMOTE_PROC_DOMAIN_RESET.
+func (l *Libvirt) DomainReset(Dom Domain, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainResetArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(245, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSnapshotNumChildren is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_NUM_CHILDREN.
+func (l *Libvirt) DomainSnapshotNumChildren(Snap DomainSnapshot, Flags uint32) (rNum int32, err error) {
+	var buf []byte
+
+	args := DomainSnapshotNumChildrenArgs {
+		Snap: Snap,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(246, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Num: int32
+	_, err = dec.Decode(&rNum)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSnapshotListChildrenNames is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_CHILDREN_NAMES.
+func (l *Libvirt) DomainSnapshotListChildrenNames(Snap DomainSnapshot, Maxnames int32, Flags uint32) (rNames []string, err error) {
+	var buf []byte
+
+	args := DomainSnapshotListChildrenNamesArgs {
+		Snap: Snap,
+		Maxnames: Maxnames,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(247, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Names: []string
+	_, err = dec.Decode(&rNames)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventDiskChange is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_DISK_CHANGE.
+func (l *Libvirt) DomainEventDiskChange() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(248, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainOpenGraphics is the go wrapper for REMOTE_PROC_DOMAIN_OPEN_GRAPHICS.
+func (l *Libvirt) DomainOpenGraphics(Dom Domain, Idx uint32, Flags DomainOpenGraphicsFlags) (err error) {
+	var buf []byte
+
+	args := DomainOpenGraphicsArgs {
+		Dom: Dom,
+		Idx: Idx,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(249, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeSuspendForDuration is the go wrapper for REMOTE_PROC_NODE_SUSPEND_FOR_DURATION.
+func (l *Libvirt) NodeSuspendForDuration(Target uint32, Duration uint64, Flags uint32) (err error) {
+	var buf []byte
+
+	args := NodeSuspendForDurationArgs {
+		Target: Target,
+		Duration: Duration,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(250, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainBlockResize is the go wrapper for REMOTE_PROC_DOMAIN_BLOCK_RESIZE.
+func (l *Libvirt) DomainBlockResize(Dom Domain, Disk string, Size uint64, Flags DomainBlockResizeFlags) (err error) {
+	var buf []byte
+
+	args := DomainBlockResizeArgs {
+		Dom: Dom,
+		Disk: Disk,
+		Size: Size,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(251, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetBlockIOTune is the go wrapper for REMOTE_PROC_DOMAIN_SET_BLOCK_IO_TUNE.
+func (l *Libvirt) DomainSetBlockIOTune(Dom Domain, Disk string, Params []TypedParam, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainSetBlockIOTuneArgs {
+		Dom: Dom,
+		Disk: Disk,
+		Params: Params,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(252, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetBlockIOTune is the go wrapper for REMOTE_PROC_DOMAIN_GET_BLOCK_IO_TUNE.
+func (l *Libvirt) DomainGetBlockIOTune(Dom Domain, Disk OptString, Nparams int32, Flags uint32) (rParams []TypedParam, rNparams int32, err error) {
+	var buf []byte
+
+	args := DomainGetBlockIOTuneArgs {
+		Dom: Dom,
+		Disk: Disk,
+		Nparams: Nparams,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(253, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Params: []TypedParam
+	_, err = dec.Decode(&rParams)
+	if err != nil {
+		return
+	}
+	// Nparams: int32
+	_, err = dec.Decode(&rNparams)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetNumaParameters is the go wrapper for REMOTE_PROC_DOMAIN_SET_NUMA_PARAMETERS.
+func (l *Libvirt) DomainSetNumaParameters(Dom Domain, Params []TypedParam, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainSetNumaParametersArgs {
+		Dom: Dom,
+		Params: Params,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(254, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetNumaParameters is the go wrapper for REMOTE_PROC_DOMAIN_GET_NUMA_PARAMETERS.
+func (l *Libvirt) DomainGetNumaParameters(Dom Domain, Nparams int32, Flags uint32) (rParams []TypedParam, rNparams int32, err error) {
+	var buf []byte
+
+	args := DomainGetNumaParametersArgs {
+		Dom: Dom,
+		Nparams: Nparams,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(255, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Params: []TypedParam
+	_, err = dec.Decode(&rParams)
+	if err != nil {
+		return
+	}
+	// Nparams: int32
+	_, err = dec.Decode(&rNparams)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetInterfaceParameters is the go wrapper for REMOTE_PROC_DOMAIN_SET_INTERFACE_PARAMETERS.
+func (l *Libvirt) DomainSetInterfaceParameters(Dom Domain, Device string, Params []TypedParam, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainSetInterfaceParametersArgs {
+		Dom: Dom,
+		Device: Device,
+		Params: Params,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(256, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetInterfaceParameters is the go wrapper for REMOTE_PROC_DOMAIN_GET_INTERFACE_PARAMETERS.
+func (l *Libvirt) DomainGetInterfaceParameters(Dom Domain, Device string, Nparams int32, Flags DomainModificationImpact) (rParams []TypedParam, rNparams int32, err error) {
+	var buf []byte
+
+	args := DomainGetInterfaceParametersArgs {
+		Dom: Dom,
+		Device: Device,
+		Nparams: Nparams,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(257, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Params: []TypedParam
+	_, err = dec.Decode(&rParams)
+	if err != nil {
+		return
+	}
+	// Nparams: int32
+	_, err = dec.Decode(&rNparams)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainShutdownFlags is the go wrapper for REMOTE_PROC_DOMAIN_SHUTDOWN_FLAGS.
+func (l *Libvirt) DomainShutdownFlags(Dom Domain, Flags DomainShutdownFlagValues) (err error) {
+	var buf []byte
+
+	args := DomainShutdownFlagsArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(258, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StorageVolWipePattern is the go wrapper for REMOTE_PROC_STORAGE_VOL_WIPE_PATTERN.
+func (l *Libvirt) StorageVolWipePattern(Vol StorageVol, Algorithm uint32, Flags uint32) (err error) {
+	var buf []byte
+
+	args := StorageVolWipePatternArgs {
+		Vol: Vol,
+		Algorithm: Algorithm,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(259, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StorageVolResize is the go wrapper for REMOTE_PROC_STORAGE_VOL_RESIZE.
+func (l *Libvirt) StorageVolResize(Vol StorageVol, Capacity uint64, Flags StorageVolResizeFlags) (err error) {
+	var buf []byte
+
+	args := StorageVolResizeArgs {
+		Vol: Vol,
+		Capacity: Capacity,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(260, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainPmSuspendForDuration is the go wrapper for REMOTE_PROC_DOMAIN_PM_SUSPEND_FOR_DURATION.
+func (l *Libvirt) DomainPmSuspendForDuration(Dom Domain, Target uint32, Duration uint64, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainPmSuspendForDurationArgs {
+		Dom: Dom,
+		Target: Target,
+		Duration: Duration,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(261, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetCPUStats is the go wrapper for REMOTE_PROC_DOMAIN_GET_CPU_STATS.
+func (l *Libvirt) DomainGetCPUStats(Dom Domain, Nparams uint32, StartCPU int32, Ncpus uint32, Flags TypedParameterFlags) (rParams []TypedParam, rNparams int32, err error) {
+	var buf []byte
+
+	args := DomainGetCPUStatsArgs {
+		Dom: Dom,
+		Nparams: Nparams,
+		StartCPU: StartCPU,
+		Ncpus: Ncpus,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(262, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Params: []TypedParam
+	_, err = dec.Decode(&rParams)
+	if err != nil {
+		return
+	}
+	// Nparams: int32
+	_, err = dec.Decode(&rNparams)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetDiskErrors is the go wrapper for REMOTE_PROC_DOMAIN_GET_DISK_ERRORS.
+func (l *Libvirt) DomainGetDiskErrors(Dom Domain, Maxerrors uint32, Flags uint32) (rErrors []DomainDiskError, rNerrors int32, err error) {
+	var buf []byte
+
+	args := DomainGetDiskErrorsArgs {
+		Dom: Dom,
+		Maxerrors: Maxerrors,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(263, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Errors: []DomainDiskError
+	_, err = dec.Decode(&rErrors)
+	if err != nil {
+		return
+	}
+	// Nerrors: int32
+	_, err = dec.Decode(&rNerrors)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetMetadata is the go wrapper for REMOTE_PROC_DOMAIN_SET_METADATA.
+func (l *Libvirt) DomainSetMetadata(Dom Domain, Type int32, Metadata OptString, Key OptString, Uri OptString, Flags DomainModificationImpact) (err error) {
+	var buf []byte
+
+	args := DomainSetMetadataArgs {
+		Dom: Dom,
+		Type: Type,
+		Metadata: Metadata,
+		Key: Key,
+		Uri: Uri,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(264, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetMetadata is the go wrapper for REMOTE_PROC_DOMAIN_GET_METADATA.
+func (l *Libvirt) DomainGetMetadata(Dom Domain, Type int32, Uri OptString, Flags DomainModificationImpact) (rMetadata string, err error) {
+	var buf []byte
+
+	args := DomainGetMetadataArgs {
+		Dom: Dom,
+		Type: Type,
+		Uri: Uri,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(265, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Metadata: string
+	_, err = dec.Decode(&rMetadata)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainBlockRebase is the go wrapper for REMOTE_PROC_DOMAIN_BLOCK_REBASE.
+func (l *Libvirt) DomainBlockRebase(Dom Domain, Path string, Base OptString, Bandwidth uint64, Flags DomainBlockRebaseFlags) (err error) {
+	var buf []byte
+
+	args := DomainBlockRebaseArgs {
+		Dom: Dom,
+		Path: Path,
+		Base: Base,
+		Bandwidth: Bandwidth,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(266, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainPmWakeup is the go wrapper for REMOTE_PROC_DOMAIN_PM_WAKEUP.
+func (l *Libvirt) DomainPmWakeup(Dom Domain, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainPmWakeupArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(267, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventTrayChange is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_TRAY_CHANGE.
+func (l *Libvirt) DomainEventTrayChange() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(268, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventPmwakeup is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_PMWAKEUP.
+func (l *Libvirt) DomainEventPmwakeup() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(269, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventPmsuspend is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND.
+func (l *Libvirt) DomainEventPmsuspend() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(270, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSnapshotIsCurrent is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_IS_CURRENT.
+func (l *Libvirt) DomainSnapshotIsCurrent(Snap DomainSnapshot, Flags uint32) (rCurrent int32, err error) {
+	var buf []byte
+
+	args := DomainSnapshotIsCurrentArgs {
+		Snap: Snap,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(271, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Current: int32
+	_, err = dec.Decode(&rCurrent)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSnapshotHasMetadata is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_HAS_METADATA.
+func (l *Libvirt) DomainSnapshotHasMetadata(Snap DomainSnapshot, Flags uint32) (rMetadata int32, err error) {
+	var buf []byte
+
+	args := DomainSnapshotHasMetadataArgs {
+		Snap: Snap,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(272, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Metadata: int32
+	_, err = dec.Decode(&rMetadata)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectListAllDomains is the go wrapper for REMOTE_PROC_CONNECT_LIST_ALL_DOMAINS.
+func (l *Libvirt) ConnectListAllDomains(NeedResults int32, Flags ConnectListAllDomainsFlags) (rDomains []Domain, rRet uint32, err error) {
+	var buf []byte
+
+	args := ConnectListAllDomainsArgs {
+		NeedResults: NeedResults,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(273, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Domains: []Domain
+	_, err = dec.Decode(&rDomains)
+	if err != nil {
+		return
+	}
+	// Ret: uint32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainListAllSnapshots is the go wrapper for REMOTE_PROC_DOMAIN_LIST_ALL_SNAPSHOTS.
+func (l *Libvirt) DomainListAllSnapshots(Dom Domain, NeedResults int32, Flags uint32) (rSnapshots []DomainSnapshot, rRet int32, err error) {
+	var buf []byte
+
+	args := DomainListAllSnapshotsArgs {
+		Dom: Dom,
+		NeedResults: NeedResults,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(274, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Snapshots: []DomainSnapshot
+	_, err = dec.Decode(&rSnapshots)
+	if err != nil {
+		return
+	}
+	// Ret: int32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSnapshotListAllChildren is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_ALL_CHILDREN.
+func (l *Libvirt) DomainSnapshotListAllChildren(Snapshot DomainSnapshot, NeedResults int32, Flags uint32) (rSnapshots []DomainSnapshot, rRet int32, err error) {
+	var buf []byte
+
+	args := DomainSnapshotListAllChildrenArgs {
+		Snapshot: Snapshot,
+		NeedResults: NeedResults,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(275, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Snapshots: []DomainSnapshot
+	_, err = dec.Decode(&rSnapshots)
+	if err != nil {
+		return
+	}
+	// Ret: int32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventBalloonChange is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_BALLOON_CHANGE.
+func (l *Libvirt) DomainEventBalloonChange() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(276, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetHostname is the go wrapper for REMOTE_PROC_DOMAIN_GET_HOSTNAME.
+func (l *Libvirt) DomainGetHostname(Dom Domain, Flags uint32) (rHostname string, err error) {
+	var buf []byte
+
+	args := DomainGetHostnameArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(277, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Hostname: string
+	_, err = dec.Decode(&rHostname)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetSecurityLabelList is the go wrapper for REMOTE_PROC_DOMAIN_GET_SECURITY_LABEL_LIST.
+func (l *Libvirt) DomainGetSecurityLabelList(Dom Domain) (rLabels []DomainGetSecurityLabelRet, rRet int32, err error) {
+	var buf []byte
+
+	args := DomainGetSecurityLabelListArgs {
+		Dom: Dom,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(278, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Labels: []DomainGetSecurityLabelRet
+	_, err = dec.Decode(&rLabels)
+	if err != nil {
+		return
+	}
+	// Ret: int32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainPinEmulator is the go wrapper for REMOTE_PROC_DOMAIN_PIN_EMULATOR.
+func (l *Libvirt) DomainPinEmulator(Dom Domain, Cpumap []byte, Flags DomainModificationImpact) (err error) {
+	var buf []byte
+
+	args := DomainPinEmulatorArgs {
+		Dom: Dom,
+		Cpumap: Cpumap,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(279, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetEmulatorPinInfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_EMULATOR_PIN_INFO.
+func (l *Libvirt) DomainGetEmulatorPinInfo(Dom Domain, Maplen int32, Flags DomainModificationImpact) (rCpumaps []byte, rRet int32, err error) {
+	var buf []byte
+
+	args := DomainGetEmulatorPinInfoArgs {
+		Dom: Dom,
+		Maplen: Maplen,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(280, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Cpumaps: []byte
+	_, err = dec.Decode(&rCpumaps)
+	if err != nil {
+		return
+	}
+	// Ret: int32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectListAllStoragePools is the go wrapper for REMOTE_PROC_CONNECT_LIST_ALL_STORAGE_POOLS.
+func (l *Libvirt) ConnectListAllStoragePools(NeedResults int32, Flags ConnectListAllStoragePoolsFlags) (rPools []StoragePool, rRet uint32, err error) {
+	var buf []byte
+
+	args := ConnectListAllStoragePoolsArgs {
+		NeedResults: NeedResults,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(281, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Pools: []StoragePool
+	_, err = dec.Decode(&rPools)
+	if err != nil {
+		return
+	}
+	// Ret: uint32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolListAllVolumes is the go wrapper for REMOTE_PROC_STORAGE_POOL_LIST_ALL_VOLUMES.
+func (l *Libvirt) StoragePoolListAllVolumes(Pool StoragePool, NeedResults int32, Flags uint32) (rVols []StorageVol, rRet uint32, err error) {
+	var buf []byte
+
+	args := StoragePoolListAllVolumesArgs {
+		Pool: Pool,
+		NeedResults: NeedResults,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(282, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Vols: []StorageVol
+	_, err = dec.Decode(&rVols)
+	if err != nil {
+		return
+	}
+	// Ret: uint32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectListAllNetworks is the go wrapper for REMOTE_PROC_CONNECT_LIST_ALL_NETWORKS.
+func (l *Libvirt) ConnectListAllNetworks(NeedResults int32, Flags ConnectListAllNetworksFlags) (rNets []Network, rRet uint32, err error) {
+	var buf []byte
+
+	args := ConnectListAllNetworksArgs {
+		NeedResults: NeedResults,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(283, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Nets: []Network
+	_, err = dec.Decode(&rNets)
+	if err != nil {
+		return
+	}
+	// Ret: uint32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectListAllInterfaces is the go wrapper for REMOTE_PROC_CONNECT_LIST_ALL_INTERFACES.
+func (l *Libvirt) ConnectListAllInterfaces(NeedResults int32, Flags ConnectListAllInterfacesFlags) (rIfaces []Interface, rRet uint32, err error) {
+	var buf []byte
+
+	args := ConnectListAllInterfacesArgs {
+		NeedResults: NeedResults,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(284, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Ifaces: []Interface
+	_, err = dec.Decode(&rIfaces)
+	if err != nil {
+		return
+	}
+	// Ret: uint32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectListAllNodeDevices is the go wrapper for REMOTE_PROC_CONNECT_LIST_ALL_NODE_DEVICES.
+func (l *Libvirt) ConnectListAllNodeDevices(NeedResults int32, Flags uint32) (rDevices []NodeDevice, rRet uint32, err error) {
+	var buf []byte
+
+	args := ConnectListAllNodeDevicesArgs {
+		NeedResults: NeedResults,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(285, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Devices: []NodeDevice
+	_, err = dec.Decode(&rDevices)
+	if err != nil {
+		return
+	}
+	// Ret: uint32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectListAllNwfilters is the go wrapper for REMOTE_PROC_CONNECT_LIST_ALL_NWFILTERS.
+func (l *Libvirt) ConnectListAllNwfilters(NeedResults int32, Flags uint32) (rFilters []Nwfilter, rRet uint32, err error) {
+	var buf []byte
+
+	args := ConnectListAllNwfiltersArgs {
+		NeedResults: NeedResults,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(286, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Filters: []Nwfilter
+	_, err = dec.Decode(&rFilters)
+	if err != nil {
+		return
+	}
+	// Ret: uint32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectListAllSecrets is the go wrapper for REMOTE_PROC_CONNECT_LIST_ALL_SECRETS.
+func (l *Libvirt) ConnectListAllSecrets(NeedResults int32, Flags ConnectListAllSecretsFlags) (rSecrets []Secret, rRet uint32, err error) {
+	var buf []byte
+
+	args := ConnectListAllSecretsArgs {
+		NeedResults: NeedResults,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(287, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Secrets: []Secret
+	_, err = dec.Decode(&rSecrets)
+	if err != nil {
+		return
+	}
+	// Ret: uint32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeSetMemoryParameters is the go wrapper for REMOTE_PROC_NODE_SET_MEMORY_PARAMETERS.
+func (l *Libvirt) NodeSetMemoryParameters(Params []TypedParam, Flags uint32) (err error) {
+	var buf []byte
+
+	args := NodeSetMemoryParametersArgs {
+		Params: Params,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(288, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeGetMemoryParameters is the go wrapper for REMOTE_PROC_NODE_GET_MEMORY_PARAMETERS.
+func (l *Libvirt) NodeGetMemoryParameters(Nparams int32, Flags uint32) (rParams []TypedParam, rNparams int32, err error) {
+	var buf []byte
+
+	args := NodeGetMemoryParametersArgs {
+		Nparams: Nparams,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(289, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Params: []TypedParam
+	_, err = dec.Decode(&rParams)
+	if err != nil {
+		return
+	}
+	// Nparams: int32
+	_, err = dec.Decode(&rNparams)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainBlockCommit is the go wrapper for REMOTE_PROC_DOMAIN_BLOCK_COMMIT.
+func (l *Libvirt) DomainBlockCommit(Dom Domain, Disk string, Base OptString, Top OptString, Bandwidth uint64, Flags DomainBlockCommitFlags) (err error) {
+	var buf []byte
+
+	args := DomainBlockCommitArgs {
+		Dom: Dom,
+		Disk: Disk,
+		Base: Base,
+		Top: Top,
+		Bandwidth: Bandwidth,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(290, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkUpdate is the go wrapper for REMOTE_PROC_NETWORK_UPDATE.
+func (l *Libvirt) NetworkUpdate(Net Network, Command uint32, Section uint32, ParentIndex int32, XML string, Flags NetworkUpdateFlags) (err error) {
+	var buf []byte
+
+	args := NetworkUpdateArgs {
+		Net: Net,
+		Command: Command,
+		Section: Section,
+		ParentIndex: ParentIndex,
+		XML: XML,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(291, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventPmsuspendDisk is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND_DISK.
+func (l *Libvirt) DomainEventPmsuspendDisk() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(292, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeGetCPUMap is the go wrapper for REMOTE_PROC_NODE_GET_CPU_MAP.
+func (l *Libvirt) NodeGetCPUMap(NeedMap int32, NeedOnline int32, Flags uint32) (rCpumap []byte, rOnline uint32, rRet int32, err error) {
+	var buf []byte
+
+	args := NodeGetCPUMapArgs {
+		NeedMap: NeedMap,
+		NeedOnline: NeedOnline,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(293, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Cpumap: []byte
+	_, err = dec.Decode(&rCpumap)
+	if err != nil {
+		return
+	}
+	// Online: uint32
+	_, err = dec.Decode(&rOnline)
+	if err != nil {
+		return
+	}
+	// Ret: int32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainFstrim is the go wrapper for REMOTE_PROC_DOMAIN_FSTRIM.
+func (l *Libvirt) DomainFstrim(Dom Domain, MountPoint OptString, Minimum uint64, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainFstrimArgs {
+		Dom: Dom,
+		MountPoint: MountPoint,
+		Minimum: Minimum,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(294, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSendProcessSignal is the go wrapper for REMOTE_PROC_DOMAIN_SEND_PROCESS_SIGNAL.
+func (l *Libvirt) DomainSendProcessSignal(Dom Domain, PidValue int64, Signum uint32, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainSendProcessSignalArgs {
+		Dom: Dom,
+		PidValue: PidValue,
+		Signum: Signum,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(295, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainOpenChannel is the go wrapper for REMOTE_PROC_DOMAIN_OPEN_CHANNEL.
+func (l *Libvirt) DomainOpenChannel(Dom Domain, Name OptString, inStream io.Writer, Flags DomainChannelFlags) (err error) {
+	var buf []byte
+
+	args := DomainOpenChannelArgs {
+		Dom: Dom,
+		Name: Name,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(296, constants.Program, buf, nil, inStream)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeDeviceLookupScsiHostByWwn is the go wrapper for REMOTE_PROC_NODE_DEVICE_LOOKUP_SCSI_HOST_BY_WWN.
+func (l *Libvirt) NodeDeviceLookupScsiHostByWwn(Wwnn string, Wwpn string, Flags uint32) (rDev NodeDevice, err error) {
+	var buf []byte
+
+	args := NodeDeviceLookupScsiHostByWwnArgs {
+		Wwnn: Wwnn,
+		Wwpn: Wwpn,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(297, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Dev: NodeDevice
+	_, err = dec.Decode(&rDev)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetJobStats is the go wrapper for REMOTE_PROC_DOMAIN_GET_JOB_STATS.
+func (l *Libvirt) DomainGetJobStats(Dom Domain, Flags DomainGetJobStatsFlags) (rType int32, rParams []TypedParam, err error) {
+	var buf []byte
+
+	args := DomainGetJobStatsArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(298, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Type: int32
+	_, err = dec.Decode(&rType)
+	if err != nil {
+		return
+	}
+	// Params: []TypedParam
+	_, err = dec.Decode(&rParams)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigrateGetCompressionCache is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_GET_COMPRESSION_CACHE.
+func (l *Libvirt) DomainMigrateGetCompressionCache(Dom Domain, Flags uint32) (rCacheSize uint64, err error) {
+	var buf []byte
+
+	args := DomainMigrateGetCompressionCacheArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(299, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// CacheSize: uint64
+	_, err = dec.Decode(&rCacheSize)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigrateSetCompressionCache is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_SET_COMPRESSION_CACHE.
+func (l *Libvirt) DomainMigrateSetCompressionCache(Dom Domain, CacheSize uint64, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainMigrateSetCompressionCacheArgs {
+		Dom: Dom,
+		CacheSize: CacheSize,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(300, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeDeviceDetachFlags is the go wrapper for REMOTE_PROC_NODE_DEVICE_DETACH_FLAGS.
+func (l *Libvirt) NodeDeviceDetachFlags(Name string, DriverName OptString, Flags uint32) (err error) {
+	var buf []byte
+
+	args := NodeDeviceDetachFlagsArgs {
+		Name: Name,
+		DriverName: DriverName,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(301, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigrateBegin3Params is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_BEGIN3_PARAMS.
+func (l *Libvirt) DomainMigrateBegin3Params(Dom Domain, Params []TypedParam, Flags uint32) (rCookieOut []byte, rXML string, err error) {
+	var buf []byte
+
+	args := DomainMigrateBegin3ParamsArgs {
+		Dom: Dom,
+		Params: Params,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(302, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// CookieOut: []byte
+	_, err = dec.Decode(&rCookieOut)
+	if err != nil {
+		return
+	}
+	// XML: string
+	_, err = dec.Decode(&rXML)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigratePrepare3Params is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_PREPARE3_PARAMS.
+func (l *Libvirt) DomainMigratePrepare3Params(Params []TypedParam, CookieIn []byte, Flags uint32) (rCookieOut []byte, rUriOut OptString, err error) {
+	var buf []byte
+
+	args := DomainMigratePrepare3ParamsArgs {
+		Params: Params,
+		CookieIn: CookieIn,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(303, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// CookieOut: []byte
+	_, err = dec.Decode(&rCookieOut)
+	if err != nil {
+		return
+	}
+	// UriOut: OptString
+	_, err = dec.Decode(&rUriOut)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigratePrepareTunnel3Params is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL3_PARAMS.
+func (l *Libvirt) DomainMigratePrepareTunnel3Params(Params []TypedParam, CookieIn []byte, Flags uint32) (rCookieOut []byte, err error) {
+	var buf []byte
+
+	args := DomainMigratePrepareTunnel3ParamsArgs {
+		Params: Params,
+		CookieIn: CookieIn,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(304, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// CookieOut: []byte
+	_, err = dec.Decode(&rCookieOut)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigratePerform3Params is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_PERFORM3_PARAMS.
+func (l *Libvirt) DomainMigratePerform3Params(Dom Domain, Dconnuri OptString, Params []TypedParam, CookieIn []byte, Flags DomainMigrateFlags) (rCookieOut []byte, err error) {
+	var buf []byte
+
+	args := DomainMigratePerform3ParamsArgs {
+		Dom: Dom,
+		Dconnuri: Dconnuri,
+		Params: Params,
+		CookieIn: CookieIn,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(305, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// CookieOut: []byte
+	_, err = dec.Decode(&rCookieOut)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigrateFinish3Params is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_FINISH3_PARAMS.
+func (l *Libvirt) DomainMigrateFinish3Params(Params []TypedParam, CookieIn []byte, Flags uint32, Cancelled int32) (rDom Domain, rCookieOut []byte, err error) {
+	var buf []byte
+
+	args := DomainMigrateFinish3ParamsArgs {
+		Params: Params,
+		CookieIn: CookieIn,
+		Flags: Flags,
+		Cancelled: Cancelled,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(306, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Dom: Domain
+	_, err = dec.Decode(&rDom)
+	if err != nil {
+		return
+	}
+	// CookieOut: []byte
+	_, err = dec.Decode(&rCookieOut)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigrateConfirm3Params is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_CONFIRM3_PARAMS.
+func (l *Libvirt) DomainMigrateConfirm3Params(Dom Domain, Params []TypedParam, CookieIn []byte, Flags uint32, Cancelled int32) (err error) {
+	var buf []byte
+
+	args := DomainMigrateConfirm3ParamsArgs {
+		Dom: Dom,
+		Params: Params,
+		CookieIn: CookieIn,
+		Flags: Flags,
+		Cancelled: Cancelled,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(307, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetMemoryStatsPeriod is the go wrapper for REMOTE_PROC_DOMAIN_SET_MEMORY_STATS_PERIOD.
+func (l *Libvirt) DomainSetMemoryStatsPeriod(Dom Domain, Period int32, Flags DomainMemoryModFlags) (err error) {
+	var buf []byte
+
+	args := DomainSetMemoryStatsPeriodArgs {
+		Dom: Dom,
+		Period: Period,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(308, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainCreateXMLWithFiles is the go wrapper for REMOTE_PROC_DOMAIN_CREATE_XML_WITH_FILES.
+func (l *Libvirt) DomainCreateXMLWithFiles(XMLDesc string, Flags DomainCreateFlags) (rDom Domain, err error) {
+	var buf []byte
+
+	args := DomainCreateXMLWithFilesArgs {
+		XMLDesc: XMLDesc,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(309, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Dom: Domain
+	_, err = dec.Decode(&rDom)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainCreateWithFiles is the go wrapper for REMOTE_PROC_DOMAIN_CREATE_WITH_FILES.
+func (l *Libvirt) DomainCreateWithFiles(Dom Domain, Flags DomainCreateFlags) (rDom Domain, err error) {
+	var buf []byte
+
+	args := DomainCreateWithFilesArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(310, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Dom: Domain
+	_, err = dec.Decode(&rDom)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventDeviceRemoved is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_DEVICE_REMOVED.
+func (l *Libvirt) DomainEventDeviceRemoved() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(311, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectGetCPUModelNames is the go wrapper for REMOTE_PROC_CONNECT_GET_CPU_MODEL_NAMES.
+func (l *Libvirt) ConnectGetCPUModelNames(Arch string, NeedResults int32, Flags uint32) (rModels []string, rRet int32, err error) {
+	var buf []byte
+
+	args := ConnectGetCPUModelNamesArgs {
+		Arch: Arch,
+		NeedResults: NeedResults,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(312, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Models: []string
+	_, err = dec.Decode(&rModels)
+	if err != nil {
+		return
+	}
+	// Ret: int32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectNetworkEventRegisterAny is the go wrapper for REMOTE_PROC_CONNECT_NETWORK_EVENT_REGISTER_ANY.
+func (l *Libvirt) ConnectNetworkEventRegisterAny(EventID int32, Net OptNetwork) (rCallbackID int32, err error) {
+	var buf []byte
+
+	args := ConnectNetworkEventRegisterAnyArgs {
+		EventID: EventID,
+		Net: Net,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(313, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// CallbackID: int32
+	_, err = dec.Decode(&rCallbackID)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectNetworkEventDeregisterAny is the go wrapper for REMOTE_PROC_CONNECT_NETWORK_EVENT_DEREGISTER_ANY.
+func (l *Libvirt) ConnectNetworkEventDeregisterAny(CallbackID int32) (err error) {
+	var buf []byte
+
+	args := ConnectNetworkEventDeregisterAnyArgs {
+		CallbackID: CallbackID,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(314, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkEventLifecycle is the go wrapper for REMOTE_PROC_NETWORK_EVENT_LIFECYCLE.
+func (l *Libvirt) NetworkEventLifecycle() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(315, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectDomainEventCallbackRegisterAny is the go wrapper for REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_REGISTER_ANY.
+func (l *Libvirt) ConnectDomainEventCallbackRegisterAny(EventID int32, Dom OptDomain) (rCallbackID int32, err error) {
+	var buf []byte
+
+	args := ConnectDomainEventCallbackRegisterAnyArgs {
+		EventID: EventID,
+		Dom: Dom,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(316, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// CallbackID: int32
+	_, err = dec.Decode(&rCallbackID)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectDomainEventCallbackDeregisterAny is the go wrapper for REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_DEREGISTER_ANY.
+func (l *Libvirt) ConnectDomainEventCallbackDeregisterAny(CallbackID int32) (err error) {
+	var buf []byte
+
+	args := ConnectDomainEventCallbackDeregisterAnyArgs {
+		CallbackID: CallbackID,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(317, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackLifecycle is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_LIFECYCLE.
+func (l *Libvirt) DomainEventCallbackLifecycle() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(318, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackReboot is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_REBOOT.
+func (l *Libvirt) DomainEventCallbackReboot() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(319, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackRtcChange is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_RTC_CHANGE.
+func (l *Libvirt) DomainEventCallbackRtcChange() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(320, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackWatchdog is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_WATCHDOG.
+func (l *Libvirt) DomainEventCallbackWatchdog() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(321, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackIOError is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR.
+func (l *Libvirt) DomainEventCallbackIOError() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(322, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackGraphics is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_GRAPHICS.
+func (l *Libvirt) DomainEventCallbackGraphics() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(323, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackIOErrorReason is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR_REASON.
+func (l *Libvirt) DomainEventCallbackIOErrorReason() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(324, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackControlError is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_CONTROL_ERROR.
+func (l *Libvirt) DomainEventCallbackControlError() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(325, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackBlockJob is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BLOCK_JOB.
+func (l *Libvirt) DomainEventCallbackBlockJob() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(326, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackDiskChange is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DISK_CHANGE.
+func (l *Libvirt) DomainEventCallbackDiskChange() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(327, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackTrayChange is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_TRAY_CHANGE.
+func (l *Libvirt) DomainEventCallbackTrayChange() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(328, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackPmwakeup is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMWAKEUP.
+func (l *Libvirt) DomainEventCallbackPmwakeup() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(329, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackPmsuspend is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND.
+func (l *Libvirt) DomainEventCallbackPmsuspend() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(330, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackBalloonChange is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BALLOON_CHANGE.
+func (l *Libvirt) DomainEventCallbackBalloonChange() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(331, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackPmsuspendDisk is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND_DISK.
+func (l *Libvirt) DomainEventCallbackPmsuspendDisk() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(332, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackDeviceRemoved is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_REMOVED.
+func (l *Libvirt) DomainEventCallbackDeviceRemoved() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(333, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainCoreDumpWithFormat is the go wrapper for REMOTE_PROC_DOMAIN_CORE_DUMP_WITH_FORMAT.
+func (l *Libvirt) DomainCoreDumpWithFormat(Dom Domain, To string, Dumpformat uint32, Flags DomainCoreDumpFlags) (err error) {
+	var buf []byte
+
+	args := DomainCoreDumpWithFormatArgs {
+		Dom: Dom,
+		To: To,
+		Dumpformat: Dumpformat,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(334, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainFsfreeze is the go wrapper for REMOTE_PROC_DOMAIN_FSFREEZE.
+func (l *Libvirt) DomainFsfreeze(Dom Domain, Mountpoints []string, Flags uint32) (rFilesystems int32, err error) {
+	var buf []byte
+
+	args := DomainFsfreezeArgs {
+		Dom: Dom,
+		Mountpoints: Mountpoints,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(335, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Filesystems: int32
+	_, err = dec.Decode(&rFilesystems)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainFsthaw is the go wrapper for REMOTE_PROC_DOMAIN_FSTHAW.
+func (l *Libvirt) DomainFsthaw(Dom Domain, Mountpoints []string, Flags uint32) (rFilesystems int32, err error) {
+	var buf []byte
+
+	args := DomainFsthawArgs {
+		Dom: Dom,
+		Mountpoints: Mountpoints,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(336, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Filesystems: int32
+	_, err = dec.Decode(&rFilesystems)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetTime is the go wrapper for REMOTE_PROC_DOMAIN_GET_TIME.
+func (l *Libvirt) DomainGetTime(Dom Domain, Flags uint32) (rSeconds int64, rNseconds uint32, err error) {
+	var buf []byte
+
+	args := DomainGetTimeArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(337, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Seconds: int64
+	_, err = dec.Decode(&rSeconds)
+	if err != nil {
+		return
+	}
+	// Nseconds: uint32
+	_, err = dec.Decode(&rNseconds)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetTime is the go wrapper for REMOTE_PROC_DOMAIN_SET_TIME.
+func (l *Libvirt) DomainSetTime(Dom Domain, Seconds int64, Nseconds uint32, Flags DomainSetTimeFlags) (err error) {
+	var buf []byte
+
+	args := DomainSetTimeArgs {
+		Dom: Dom,
+		Seconds: Seconds,
+		Nseconds: Nseconds,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(338, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventBlockJob2 is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_BLOCK_JOB_2.
+func (l *Libvirt) DomainEventBlockJob2() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(339, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeGetFreePages is the go wrapper for REMOTE_PROC_NODE_GET_FREE_PAGES.
+func (l *Libvirt) NodeGetFreePages(Pages []uint32, StartCell int32, CellCount uint32, Flags uint32) (rCounts []uint64, err error) {
+	var buf []byte
+
+	args := NodeGetFreePagesArgs {
+		Pages: Pages,
+		StartCell: StartCell,
+		CellCount: CellCount,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(340, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Counts: []uint64
+	_, err = dec.Decode(&rCounts)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkGetDhcpLeases is the go wrapper for REMOTE_PROC_NETWORK_GET_DHCP_LEASES.
+func (l *Libvirt) NetworkGetDhcpLeases(Net Network, Mac OptString, NeedResults int32, Flags uint32) (rLeases []NetworkDhcpLease, rRet uint32, err error) {
+	var buf []byte
+
+	args := NetworkGetDhcpLeasesArgs {
+		Net: Net,
+		Mac: Mac,
+		NeedResults: NeedResults,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(341, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Leases: []NetworkDhcpLease
+	_, err = dec.Decode(&rLeases)
+	if err != nil {
+		return
+	}
+	// Ret: uint32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectGetDomainCapabilities is the go wrapper for REMOTE_PROC_CONNECT_GET_DOMAIN_CAPABILITIES.
+func (l *Libvirt) ConnectGetDomainCapabilities(Emulatorbin OptString, Arch OptString, Machine OptString, Virttype OptString, Flags uint32) (rCapabilities string, err error) {
+	var buf []byte
+
+	args := ConnectGetDomainCapabilitiesArgs {
+		Emulatorbin: Emulatorbin,
+		Arch: Arch,
+		Machine: Machine,
+		Virttype: Virttype,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(342, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Capabilities: string
+	_, err = dec.Decode(&rCapabilities)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainOpenGraphicsFd is the go wrapper for REMOTE_PROC_DOMAIN_OPEN_GRAPHICS_FD.
+func (l *Libvirt) DomainOpenGraphicsFd(Dom Domain, Idx uint32, Flags DomainOpenGraphicsFlags) (err error) {
+	var buf []byte
+
+	args := DomainOpenGraphicsFdArgs {
+		Dom: Dom,
+		Idx: Idx,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(343, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectGetAllDomainStats is the go wrapper for REMOTE_PROC_CONNECT_GET_ALL_DOMAIN_STATS.
+func (l *Libvirt) ConnectGetAllDomainStats(Doms []Domain, Stats uint32, Flags ConnectGetAllDomainStatsFlags) (rRetStats []DomainStatsRecord, err error) {
+	var buf []byte
+
+	args := ConnectGetAllDomainStatsArgs {
+		Doms: Doms,
+		Stats: Stats,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(344, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// RetStats: []DomainStatsRecord
+	_, err = dec.Decode(&rRetStats)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainBlockCopy is the go wrapper for REMOTE_PROC_DOMAIN_BLOCK_COPY.
+func (l *Libvirt) DomainBlockCopy(Dom Domain, Path string, Destxml string, Params []TypedParam, Flags DomainBlockCopyFlags) (err error) {
+	var buf []byte
+
+	args := DomainBlockCopyArgs {
+		Dom: Dom,
+		Path: Path,
+		Destxml: Destxml,
+		Params: Params,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(345, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackTunable is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_TUNABLE.
+func (l *Libvirt) DomainEventCallbackTunable() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(346, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeAllocPages is the go wrapper for REMOTE_PROC_NODE_ALLOC_PAGES.
+func (l *Libvirt) NodeAllocPages(PageSizes []uint32, PageCounts []uint64, StartCell int32, CellCount uint32, Flags NodeAllocPagesFlags) (rRet int32, err error) {
+	var buf []byte
+
+	args := NodeAllocPagesArgs {
+		PageSizes: PageSizes,
+		PageCounts: PageCounts,
+		StartCell: StartCell,
+		CellCount: CellCount,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(347, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Ret: int32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackAgentLifecycle is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_AGENT_LIFECYCLE.
+func (l *Libvirt) DomainEventCallbackAgentLifecycle() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(348, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetFsinfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_FSINFO.
+func (l *Libvirt) DomainGetFsinfo(Dom Domain, Flags uint32) (rInfo []DomainFsinfo, rRet uint32, err error) {
+	var buf []byte
+
+	args := DomainGetFsinfoArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(349, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Info: []DomainFsinfo
+	_, err = dec.Decode(&rInfo)
+	if err != nil {
+		return
+	}
+	// Ret: uint32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainDefineXMLFlags is the go wrapper for REMOTE_PROC_DOMAIN_DEFINE_XML_FLAGS.
+func (l *Libvirt) DomainDefineXMLFlags(XML string, Flags DomainDefineFlags) (rDom Domain, err error) {
+	var buf []byte
+
+	args := DomainDefineXMLFlagsArgs {
+		XML: XML,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(350, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Dom: Domain
+	_, err = dec.Decode(&rDom)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetIothreadInfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_IOTHREAD_INFO.
+func (l *Libvirt) DomainGetIothreadInfo(Dom Domain, Flags DomainModificationImpact) (rInfo []DomainIothreadInfo, rRet uint32, err error) {
+	var buf []byte
+
+	args := DomainGetIothreadInfoArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(351, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Info: []DomainIothreadInfo
+	_, err = dec.Decode(&rInfo)
+	if err != nil {
+		return
+	}
+	// Ret: uint32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainPinIothread is the go wrapper for REMOTE_PROC_DOMAIN_PIN_IOTHREAD.
+func (l *Libvirt) DomainPinIothread(Dom Domain, IothreadsID uint32, Cpumap []byte, Flags DomainModificationImpact) (err error) {
+	var buf []byte
+
+	args := DomainPinIothreadArgs {
+		Dom: Dom,
+		IothreadsID: IothreadsID,
+		Cpumap: Cpumap,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(352, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainInterfaceAddresses is the go wrapper for REMOTE_PROC_DOMAIN_INTERFACE_ADDRESSES.
+func (l *Libvirt) DomainInterfaceAddresses(Dom Domain, Source uint32, Flags uint32) (rIfaces []DomainInterface, err error) {
+	var buf []byte
+
+	args := DomainInterfaceAddressesArgs {
+		Dom: Dom,
+		Source: Source,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(353, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Ifaces: []DomainInterface
+	_, err = dec.Decode(&rIfaces)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackDeviceAdded is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_ADDED.
+func (l *Libvirt) DomainEventCallbackDeviceAdded() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(354, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainAddIothread is the go wrapper for REMOTE_PROC_DOMAIN_ADD_IOTHREAD.
+func (l *Libvirt) DomainAddIothread(Dom Domain, IothreadID uint32, Flags DomainModificationImpact) (err error) {
+	var buf []byte
+
+	args := DomainAddIothreadArgs {
+		Dom: Dom,
+		IothreadID: IothreadID,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(355, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainDelIothread is the go wrapper for REMOTE_PROC_DOMAIN_DEL_IOTHREAD.
+func (l *Libvirt) DomainDelIothread(Dom Domain, IothreadID uint32, Flags DomainModificationImpact) (err error) {
+	var buf []byte
+
+	args := DomainDelIothreadArgs {
+		Dom: Dom,
+		IothreadID: IothreadID,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(356, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetUserPassword is the go wrapper for REMOTE_PROC_DOMAIN_SET_USER_PASSWORD.
+func (l *Libvirt) DomainSetUserPassword(Dom Domain, User OptString, Password OptString, Flags DomainSetUserPasswordFlags) (err error) {
+	var buf []byte
+
+	args := DomainSetUserPasswordArgs {
+		Dom: Dom,
+		User: User,
+		Password: Password,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(357, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainRename is the go wrapper for REMOTE_PROC_DOMAIN_RENAME.
+func (l *Libvirt) DomainRename(Dom Domain, NewName OptString, Flags uint32) (rRetcode int32, err error) {
+	var buf []byte
+
+	args := DomainRenameArgs {
+		Dom: Dom,
+		NewName: NewName,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(358, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Retcode: int32
+	_, err = dec.Decode(&rRetcode)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackMigrationIteration is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_MIGRATION_ITERATION.
+func (l *Libvirt) DomainEventCallbackMigrationIteration() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(359, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectRegisterCloseCallback is the go wrapper for REMOTE_PROC_CONNECT_REGISTER_CLOSE_CALLBACK.
+func (l *Libvirt) ConnectRegisterCloseCallback() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(360, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectUnregisterCloseCallback is the go wrapper for REMOTE_PROC_CONNECT_UNREGISTER_CLOSE_CALLBACK.
+func (l *Libvirt) ConnectUnregisterCloseCallback() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(361, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectEventConnectionClosed is the go wrapper for REMOTE_PROC_CONNECT_EVENT_CONNECTION_CLOSED.
+func (l *Libvirt) ConnectEventConnectionClosed() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(362, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackJobCompleted is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_JOB_COMPLETED.
+func (l *Libvirt) DomainEventCallbackJobCompleted() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(363, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigrateStartPostCopy is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_START_POST_COPY.
+func (l *Libvirt) DomainMigrateStartPostCopy(Dom Domain, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainMigrateStartPostCopyArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(364, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetPerfEvents is the go wrapper for REMOTE_PROC_DOMAIN_GET_PERF_EVENTS.
+func (l *Libvirt) DomainGetPerfEvents(Dom Domain, Flags DomainModificationImpact) (rParams []TypedParam, err error) {
+	var buf []byte
+
+	args := DomainGetPerfEventsArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(365, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Params: []TypedParam
+	_, err = dec.Decode(&rParams)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetPerfEvents is the go wrapper for REMOTE_PROC_DOMAIN_SET_PERF_EVENTS.
+func (l *Libvirt) DomainSetPerfEvents(Dom Domain, Params []TypedParam, Flags DomainModificationImpact) (err error) {
+	var buf []byte
+
+	args := DomainSetPerfEventsArgs {
+		Dom: Dom,
+		Params: Params,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(366, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackDeviceRemovalFailed is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_REMOVAL_FAILED.
+func (l *Libvirt) DomainEventCallbackDeviceRemovalFailed() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(367, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectStoragePoolEventRegisterAny is the go wrapper for REMOTE_PROC_CONNECT_STORAGE_POOL_EVENT_REGISTER_ANY.
+func (l *Libvirt) ConnectStoragePoolEventRegisterAny(EventID int32, Pool OptStoragePool) (rCallbackID int32, err error) {
+	var buf []byte
+
+	args := ConnectStoragePoolEventRegisterAnyArgs {
+		EventID: EventID,
+		Pool: Pool,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(368, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// CallbackID: int32
+	_, err = dec.Decode(&rCallbackID)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectStoragePoolEventDeregisterAny is the go wrapper for REMOTE_PROC_CONNECT_STORAGE_POOL_EVENT_DEREGISTER_ANY.
+func (l *Libvirt) ConnectStoragePoolEventDeregisterAny(CallbackID int32) (err error) {
+	var buf []byte
+
+	args := ConnectStoragePoolEventDeregisterAnyArgs {
+		CallbackID: CallbackID,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(369, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolEventLifecycle is the go wrapper for REMOTE_PROC_STORAGE_POOL_EVENT_LIFECYCLE.
+func (l *Libvirt) StoragePoolEventLifecycle() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(370, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetGuestVcpus is the go wrapper for REMOTE_PROC_DOMAIN_GET_GUEST_VCPUS.
+func (l *Libvirt) DomainGetGuestVcpus(Dom Domain, Flags uint32) (rParams []TypedParam, err error) {
+	var buf []byte
+
+	args := DomainGetGuestVcpusArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(371, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Params: []TypedParam
+	_, err = dec.Decode(&rParams)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetGuestVcpus is the go wrapper for REMOTE_PROC_DOMAIN_SET_GUEST_VCPUS.
+func (l *Libvirt) DomainSetGuestVcpus(Dom Domain, Cpumap string, State int32, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainSetGuestVcpusArgs {
+		Dom: Dom,
+		Cpumap: Cpumap,
+		State: State,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(372, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolEventRefresh is the go wrapper for REMOTE_PROC_STORAGE_POOL_EVENT_REFRESH.
+func (l *Libvirt) StoragePoolEventRefresh() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(373, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectNodeDeviceEventRegisterAny is the go wrapper for REMOTE_PROC_CONNECT_NODE_DEVICE_EVENT_REGISTER_ANY.
+func (l *Libvirt) ConnectNodeDeviceEventRegisterAny(EventID int32, Dev OptNodeDevice) (rCallbackID int32, err error) {
+	var buf []byte
+
+	args := ConnectNodeDeviceEventRegisterAnyArgs {
+		EventID: EventID,
+		Dev: Dev,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(374, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// CallbackID: int32
+	_, err = dec.Decode(&rCallbackID)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectNodeDeviceEventDeregisterAny is the go wrapper for REMOTE_PROC_CONNECT_NODE_DEVICE_EVENT_DEREGISTER_ANY.
+func (l *Libvirt) ConnectNodeDeviceEventDeregisterAny(CallbackID int32) (err error) {
+	var buf []byte
+
+	args := ConnectNodeDeviceEventDeregisterAnyArgs {
+		CallbackID: CallbackID,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(375, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeDeviceEventLifecycle is the go wrapper for REMOTE_PROC_NODE_DEVICE_EVENT_LIFECYCLE.
+func (l *Libvirt) NodeDeviceEventLifecycle() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(376, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeDeviceEventUpdate is the go wrapper for REMOTE_PROC_NODE_DEVICE_EVENT_UPDATE.
+func (l *Libvirt) NodeDeviceEventUpdate() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(377, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StorageVolGetInfoFlags is the go wrapper for REMOTE_PROC_STORAGE_VOL_GET_INFO_FLAGS.
+func (l *Libvirt) StorageVolGetInfoFlags(Vol StorageVol, Flags uint32) (rType int8, rCapacity uint64, rAllocation uint64, err error) {
+	var buf []byte
+
+	args := StorageVolGetInfoFlagsArgs {
+		Vol: Vol,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(378, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Type: int8
+	_, err = dec.Decode(&rType)
+	if err != nil {
+		return
+	}
+	// Capacity: uint64
+	_, err = dec.Decode(&rCapacity)
+	if err != nil {
+		return
+	}
+	// Allocation: uint64
+	_, err = dec.Decode(&rAllocation)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventCallbackMetadataChange is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_METADATA_CHANGE.
+func (l *Libvirt) DomainEventCallbackMetadataChange() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(379, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectSecretEventRegisterAny is the go wrapper for REMOTE_PROC_CONNECT_SECRET_EVENT_REGISTER_ANY.
+func (l *Libvirt) ConnectSecretEventRegisterAny(EventID int32, OptSecret OptSecret) (rCallbackID int32, err error) {
+	var buf []byte
+
+	args := ConnectSecretEventRegisterAnyArgs {
+		EventID: EventID,
+		OptSecret: OptSecret,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(380, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// CallbackID: int32
+	_, err = dec.Decode(&rCallbackID)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectSecretEventDeregisterAny is the go wrapper for REMOTE_PROC_CONNECT_SECRET_EVENT_DEREGISTER_ANY.
+func (l *Libvirt) ConnectSecretEventDeregisterAny(CallbackID int32) (err error) {
+	var buf []byte
+
+	args := ConnectSecretEventDeregisterAnyArgs {
+		CallbackID: CallbackID,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(381, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// SecretEventLifecycle is the go wrapper for REMOTE_PROC_SECRET_EVENT_LIFECYCLE.
+func (l *Libvirt) SecretEventLifecycle() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(382, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// SecretEventValueChanged is the go wrapper for REMOTE_PROC_SECRET_EVENT_VALUE_CHANGED.
+func (l *Libvirt) SecretEventValueChanged() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(383, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetVcpu is the go wrapper for REMOTE_PROC_DOMAIN_SET_VCPU.
+func (l *Libvirt) DomainSetVcpu(Dom Domain, Cpumap string, State int32, Flags DomainModificationImpact) (err error) {
+	var buf []byte
+
+	args := DomainSetVcpuArgs {
+		Dom: Dom,
+		Cpumap: Cpumap,
+		State: State,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(384, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventBlockThreshold is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_BLOCK_THRESHOLD.
+func (l *Libvirt) DomainEventBlockThreshold() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(385, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetBlockThreshold is the go wrapper for REMOTE_PROC_DOMAIN_SET_BLOCK_THRESHOLD.
+func (l *Libvirt) DomainSetBlockThreshold(Dom Domain, Dev string, Threshold uint64, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainSetBlockThresholdArgs {
+		Dom: Dom,
+		Dev: Dev,
+		Threshold: Threshold,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(386, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainMigrateGetMaxDowntime is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_GET_MAX_DOWNTIME.
+func (l *Libvirt) DomainMigrateGetMaxDowntime(Dom Domain, Flags uint32) (rDowntime uint64, err error) {
+	var buf []byte
+
+	args := DomainMigrateGetMaxDowntimeArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(387, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Downtime: uint64
+	_, err = dec.Decode(&rDowntime)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainManagedSaveGetXMLDesc is the go wrapper for REMOTE_PROC_DOMAIN_MANAGED_SAVE_GET_XML_DESC.
+func (l *Libvirt) DomainManagedSaveGetXMLDesc(Dom Domain, Flags DomainXMLFlags) (rXML string, err error) {
+	var buf []byte
+
+	args := DomainManagedSaveGetXMLDescArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(388, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// XML: string
+	_, err = dec.Decode(&rXML)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainManagedSaveDefineXML is the go wrapper for REMOTE_PROC_DOMAIN_MANAGED_SAVE_DEFINE_XML.
+func (l *Libvirt) DomainManagedSaveDefineXML(Dom Domain, Dxml OptString, Flags DomainSaveRestoreFlags) (err error) {
+	var buf []byte
+
+	args := DomainManagedSaveDefineXMLArgs {
+		Dom: Dom,
+		Dxml: Dxml,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(389, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetLifecycleAction is the go wrapper for REMOTE_PROC_DOMAIN_SET_LIFECYCLE_ACTION.
+func (l *Libvirt) DomainSetLifecycleAction(Dom Domain, Type uint32, Action uint32, Flags DomainModificationImpact) (err error) {
+	var buf []byte
+
+	args := DomainSetLifecycleActionArgs {
+		Dom: Dom,
+		Type: Type,
+		Action: Action,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(390, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// StoragePoolLookupByTargetPath is the go wrapper for REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_TARGET_PATH.
+func (l *Libvirt) StoragePoolLookupByTargetPath(Path string) (rPool StoragePool, err error) {
+	var buf []byte
+
+	args := StoragePoolLookupByTargetPathArgs {
+		Path: Path,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(391, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Pool: StoragePool
+	_, err = dec.Decode(&rPool)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainDetachDeviceAlias is the go wrapper for REMOTE_PROC_DOMAIN_DETACH_DEVICE_ALIAS.
+func (l *Libvirt) DomainDetachDeviceAlias(Dom Domain, Alias string, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainDetachDeviceAliasArgs {
+		Dom: Dom,
+		Alias: Alias,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(392, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectCompareHypervisorCPU is the go wrapper for REMOTE_PROC_CONNECT_COMPARE_HYPERVISOR_CPU.
+func (l *Libvirt) ConnectCompareHypervisorCPU(Emulator OptString, Arch OptString, Machine OptString, Virttype OptString, XMLCPU string, Flags uint32) (rResult int32, err error) {
+	var buf []byte
+
+	args := ConnectCompareHypervisorCPUArgs {
+		Emulator: Emulator,
+		Arch: Arch,
+		Machine: Machine,
+		Virttype: Virttype,
+		XMLCPU: XMLCPU,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(393, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Result: int32
+	_, err = dec.Decode(&rResult)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectBaselineHypervisorCPU is the go wrapper for REMOTE_PROC_CONNECT_BASELINE_HYPERVISOR_CPU.
+func (l *Libvirt) ConnectBaselineHypervisorCPU(Emulator OptString, Arch OptString, Machine OptString, Virttype OptString, XMLCPUs []string, Flags uint32) (rCPU string, err error) {
+	var buf []byte
+
+	args := ConnectBaselineHypervisorCPUArgs {
+		Emulator: Emulator,
+		Arch: Arch,
+		Machine: Machine,
+		Virttype: Virttype,
+		XMLCPUs: XMLCPUs,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(394, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// CPU: string
+	_, err = dec.Decode(&rCPU)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NodeGetSevInfo is the go wrapper for REMOTE_PROC_NODE_GET_SEV_INFO.
+func (l *Libvirt) NodeGetSevInfo(Nparams int32, Flags uint32) (rParams []TypedParam, rNparams int32, err error) {
+	var buf []byte
+
+	args := NodeGetSevInfoArgs {
+		Nparams: Nparams,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(395, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Params: []TypedParam
+	_, err = dec.Decode(&rParams)
+	if err != nil {
+		return
+	}
+	// Nparams: int32
+	_, err = dec.Decode(&rNparams)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetLaunchSecurityInfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_LAUNCH_SECURITY_INFO.
+func (l *Libvirt) DomainGetLaunchSecurityInfo(Dom Domain, Flags uint32) (rParams []TypedParam, err error) {
+	var buf []byte
+
+	args := DomainGetLaunchSecurityInfoArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(396, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Params: []TypedParam
+	_, err = dec.Decode(&rParams)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NwfilterBindingLookupByPortDev is the go wrapper for REMOTE_PROC_NWFILTER_BINDING_LOOKUP_BY_PORT_DEV.
+func (l *Libvirt) NwfilterBindingLookupByPortDev(Name string) (rOptNwfilter NwfilterBinding, err error) {
+	var buf []byte
+
+	args := NwfilterBindingLookupByPortDevArgs {
+		Name: Name,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(397, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// OptNwfilter: NwfilterBinding
+	_, err = dec.Decode(&rOptNwfilter)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NwfilterBindingGetXMLDesc is the go wrapper for REMOTE_PROC_NWFILTER_BINDING_GET_XML_DESC.
+func (l *Libvirt) NwfilterBindingGetXMLDesc(OptNwfilter NwfilterBinding, Flags uint32) (rXML string, err error) {
+	var buf []byte
+
+	args := NwfilterBindingGetXMLDescArgs {
+		OptNwfilter: OptNwfilter,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(398, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// XML: string
+	_, err = dec.Decode(&rXML)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NwfilterBindingCreateXML is the go wrapper for REMOTE_PROC_NWFILTER_BINDING_CREATE_XML.
+func (l *Libvirt) NwfilterBindingCreateXML(XML string, Flags uint32) (rOptNwfilter NwfilterBinding, err error) {
+	var buf []byte
+
+	args := NwfilterBindingCreateXMLArgs {
+		XML: XML,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(399, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// OptNwfilter: NwfilterBinding
+	_, err = dec.Decode(&rOptNwfilter)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NwfilterBindingDelete is the go wrapper for REMOTE_PROC_NWFILTER_BINDING_DELETE.
+func (l *Libvirt) NwfilterBindingDelete(OptNwfilter NwfilterBinding) (err error) {
+	var buf []byte
+
+	args := NwfilterBindingDeleteArgs {
+		OptNwfilter: OptNwfilter,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(400, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectListAllNwfilterBindings is the go wrapper for REMOTE_PROC_CONNECT_LIST_ALL_NWFILTER_BINDINGS.
+func (l *Libvirt) ConnectListAllNwfilterBindings(NeedResults int32, Flags uint32) (rBindings []NwfilterBinding, rRet uint32, err error) {
+	var buf []byte
+
+	args := ConnectListAllNwfilterBindingsArgs {
+		NeedResults: NeedResults,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(401, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Bindings: []NwfilterBinding
+	_, err = dec.Decode(&rBindings)
+	if err != nil {
+		return
+	}
+	// Ret: uint32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainSetIothreadParams is the go wrapper for REMOTE_PROC_DOMAIN_SET_IOTHREAD_PARAMS.
+func (l *Libvirt) DomainSetIothreadParams(Dom Domain, IothreadID uint32, Params []TypedParam, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainSetIothreadParamsArgs {
+		Dom: Dom,
+		IothreadID: IothreadID,
+		Params: Params,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(402, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectGetStoragePoolCapabilities is the go wrapper for REMOTE_PROC_CONNECT_GET_STORAGE_POOL_CAPABILITIES.
+func (l *Libvirt) ConnectGetStoragePoolCapabilities(Flags uint32) (rCapabilities string, err error) {
+	var buf []byte
+
+	args := ConnectGetStoragePoolCapabilitiesArgs {
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(403, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Capabilities: string
+	_, err = dec.Decode(&rCapabilities)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkListAllPorts is the go wrapper for REMOTE_PROC_NETWORK_LIST_ALL_PORTS.
+func (l *Libvirt) NetworkListAllPorts(OptNetwork Network, NeedResults int32, Flags uint32) (rPorts []NetworkPort, rRet uint32, err error) {
+	var buf []byte
+
+	args := NetworkListAllPortsArgs {
+		OptNetwork: OptNetwork,
+		NeedResults: NeedResults,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(404, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Ports: []NetworkPort
+	_, err = dec.Decode(&rPorts)
+	if err != nil {
+		return
+	}
+	// Ret: uint32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkPortLookupByUUID is the go wrapper for REMOTE_PROC_NETWORK_PORT_LOOKUP_BY_UUID.
+func (l *Libvirt) NetworkPortLookupByUUID(OptNetwork Network, UUID UUID) (rPort NetworkPort, err error) {
+	var buf []byte
+
+	args := NetworkPortLookupByUUIDArgs {
+		OptNetwork: OptNetwork,
+		UUID: UUID,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(405, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Port: NetworkPort
+	_, err = dec.Decode(&rPort)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkPortCreateXML is the go wrapper for REMOTE_PROC_NETWORK_PORT_CREATE_XML.
+func (l *Libvirt) NetworkPortCreateXML(OptNetwork Network, XML string, Flags uint32) (rPort NetworkPort, err error) {
+	var buf []byte
+
+	args := NetworkPortCreateXMLArgs {
+		OptNetwork: OptNetwork,
+		XML: XML,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(406, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Port: NetworkPort
+	_, err = dec.Decode(&rPort)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkPortGetParameters is the go wrapper for REMOTE_PROC_NETWORK_PORT_GET_PARAMETERS.
+func (l *Libvirt) NetworkPortGetParameters(Port NetworkPort, Nparams int32, Flags uint32) (rParams []TypedParam, rNparams int32, err error) {
+	var buf []byte
+
+	args := NetworkPortGetParametersArgs {
+		Port: Port,
+		Nparams: Nparams,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(407, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Params: []TypedParam
+	_, err = dec.Decode(&rParams)
+	if err != nil {
+		return
+	}
+	// Nparams: int32
+	_, err = dec.Decode(&rNparams)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkPortSetParameters is the go wrapper for REMOTE_PROC_NETWORK_PORT_SET_PARAMETERS.
+func (l *Libvirt) NetworkPortSetParameters(Port NetworkPort, Params []TypedParam, Flags uint32) (err error) {
+	var buf []byte
+
+	args := NetworkPortSetParametersArgs {
+		Port: Port,
+		Params: Params,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(408, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkPortGetXMLDesc is the go wrapper for REMOTE_PROC_NETWORK_PORT_GET_XML_DESC.
+func (l *Libvirt) NetworkPortGetXMLDesc(Port NetworkPort, Flags uint32) (rXML string, err error) {
+	var buf []byte
+
+	args := NetworkPortGetXMLDescArgs {
+		Port: Port,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(409, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// XML: string
+	_, err = dec.Decode(&rXML)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// NetworkPortDelete is the go wrapper for REMOTE_PROC_NETWORK_PORT_DELETE.
+func (l *Libvirt) NetworkPortDelete(Port NetworkPort, Flags uint32) (err error) {
+	var buf []byte
+
+	args := NetworkPortDeleteArgs {
+		Port: Port,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(410, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainCheckpointCreateXML is the go wrapper for REMOTE_PROC_DOMAIN_CHECKPOINT_CREATE_XML.
+func (l *Libvirt) DomainCheckpointCreateXML(Dom Domain, XMLDesc string, Flags uint32) (rCheckpoint DomainCheckpoint, err error) {
+	var buf []byte
+
+	args := DomainCheckpointCreateXMLArgs {
+		Dom: Dom,
+		XMLDesc: XMLDesc,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(411, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Checkpoint: DomainCheckpoint
+	_, err = dec.Decode(&rCheckpoint)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainCheckpointGetXMLDesc is the go wrapper for REMOTE_PROC_DOMAIN_CHECKPOINT_GET_XML_DESC.
+func (l *Libvirt) DomainCheckpointGetXMLDesc(Checkpoint DomainCheckpoint, Flags uint32) (rXML string, err error) {
+	var buf []byte
+
+	args := DomainCheckpointGetXMLDescArgs {
+		Checkpoint: Checkpoint,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(412, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// XML: string
+	_, err = dec.Decode(&rXML)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainListAllCheckpoints is the go wrapper for REMOTE_PROC_DOMAIN_LIST_ALL_CHECKPOINTS.
+func (l *Libvirt) DomainListAllCheckpoints(Dom Domain, NeedResults int32, Flags uint32) (rCheckpoints []DomainCheckpoint, rRet int32, err error) {
+	var buf []byte
+
+	args := DomainListAllCheckpointsArgs {
+		Dom: Dom,
+		NeedResults: NeedResults,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(413, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Checkpoints: []DomainCheckpoint
+	_, err = dec.Decode(&rCheckpoints)
+	if err != nil {
+		return
+	}
+	// Ret: int32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainCheckpointListAllChildren is the go wrapper for REMOTE_PROC_DOMAIN_CHECKPOINT_LIST_ALL_CHILDREN.
+func (l *Libvirt) DomainCheckpointListAllChildren(Checkpoint DomainCheckpoint, NeedResults int32, Flags uint32) (rCheckpoints []DomainCheckpoint, rRet int32, err error) {
+	var buf []byte
+
+	args := DomainCheckpointListAllChildrenArgs {
+		Checkpoint: Checkpoint,
+		NeedResults: NeedResults,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(414, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Checkpoints: []DomainCheckpoint
+	_, err = dec.Decode(&rCheckpoints)
+	if err != nil {
+		return
+	}
+	// Ret: int32
+	_, err = dec.Decode(&rRet)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainCheckpointLookupByName is the go wrapper for REMOTE_PROC_DOMAIN_CHECKPOINT_LOOKUP_BY_NAME.
+func (l *Libvirt) DomainCheckpointLookupByName(Dom Domain, Name string, Flags uint32) (rCheckpoint DomainCheckpoint, err error) {
+	var buf []byte
+
+	args := DomainCheckpointLookupByNameArgs {
+		Dom: Dom,
+		Name: Name,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(415, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Checkpoint: DomainCheckpoint
+	_, err = dec.Decode(&rCheckpoint)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainCheckpointGetParent is the go wrapper for REMOTE_PROC_DOMAIN_CHECKPOINT_GET_PARENT.
+func (l *Libvirt) DomainCheckpointGetParent(Checkpoint DomainCheckpoint, Flags uint32) (rParent DomainCheckpoint, err error) {
+	var buf []byte
+
+	args := DomainCheckpointGetParentArgs {
+		Checkpoint: Checkpoint,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(416, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Parent: DomainCheckpoint
+	_, err = dec.Decode(&rParent)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainCheckpointDelete is the go wrapper for REMOTE_PROC_DOMAIN_CHECKPOINT_DELETE.
+func (l *Libvirt) DomainCheckpointDelete(Checkpoint DomainCheckpoint, Flags DomainCheckpointDeleteFlags) (err error) {
+	var buf []byte
+
+	args := DomainCheckpointDeleteArgs {
+		Checkpoint: Checkpoint,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(417, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainGetGuestInfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_GUEST_INFO.
+func (l *Libvirt) DomainGetGuestInfo(Dom Domain, Types uint32, Flags uint32) (rParams []TypedParam, err error) {
+	var buf []byte
+
+	args := DomainGetGuestInfoArgs {
+		Dom: Dom,
+		Types: Types,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(418, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Params: []TypedParam
+	_, err = dec.Decode(&rParams)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ConnectSetIdentity is the go wrapper for REMOTE_PROC_CONNECT_SET_IDENTITY.
+func (l *Libvirt) ConnectSetIdentity(Params []TypedParam, Flags uint32) (err error) {
+	var buf []byte
+
+	args := ConnectSetIdentityArgs {
+		Params: Params,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(419, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainAgentSetResponseTimeout is the go wrapper for REMOTE_PROC_DOMAIN_AGENT_SET_RESPONSE_TIMEOUT.
+func (l *Libvirt) DomainAgentSetResponseTimeout(Dom Domain, Timeout int32, Flags uint32) (rResult int32, err error) {
+	var buf []byte
+
+	args := DomainAgentSetResponseTimeoutArgs {
+		Dom: Dom,
+		Timeout: Timeout,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(420, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Result: int32
+	_, err = dec.Decode(&rResult)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainBackupBegin is the go wrapper for REMOTE_PROC_DOMAIN_BACKUP_BEGIN.
+func (l *Libvirt) DomainBackupBegin(Dom Domain, BackupXML string, CheckpointXML OptString, Flags DomainBackupBeginFlags) (err error) {
+	var buf []byte
+
+	args := DomainBackupBeginArgs {
+		Dom: Dom,
+		BackupXML: BackupXML,
+		CheckpointXML: CheckpointXML,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(421, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainBackupGetXMLDesc is the go wrapper for REMOTE_PROC_DOMAIN_BACKUP_GET_XML_DESC.
+func (l *Libvirt) DomainBackupGetXMLDesc(Dom Domain, Flags uint32) (rXML string, err error) {
+	var buf []byte
+
+	args := DomainBackupGetXMLDescArgs {
+		Dom: Dom,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(422, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// XML: string
+	_, err = dec.Decode(&rXML)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainEventMemoryFailure is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_MEMORY_FAILURE.
+func (l *Libvirt) DomainEventMemoryFailure() (err error) {
+	var buf []byte
+
+
+	_, err = l.requestStream(423, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainAuthorizedSshKeysGet is the go wrapper for REMOTE_PROC_DOMAIN_AUTHORIZED_SSH_KEYS_GET.
+func (l *Libvirt) DomainAuthorizedSshKeysGet(Dom Domain, User string, Flags uint32) (rKeys []string, err error) {
+	var buf []byte
+
+	args := DomainAuthorizedSshKeysGetArgs {
+		Dom: Dom,
+		User: User,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+	var r response
+	r, err = l.requestStream(424, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	// Return value unmarshaling
+	tpd := typedParamDecoder{}
+	ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd}
+	rdr := bytes.NewReader(r.Payload)
+	dec := xdr.NewDecoderCustomTypes(rdr, 0, ct)
+	// Keys: []string
+	_, err = dec.Decode(&rKeys)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// DomainAuthorizedSshKeysSet is the go wrapper for REMOTE_PROC_DOMAIN_AUTHORIZED_SSH_KEYS_SET.
+func (l *Libvirt) DomainAuthorizedSshKeysSet(Dom Domain, User string, Keys []string, Flags uint32) (err error) {
+	var buf []byte
+
+	args := DomainAuthorizedSshKeysSetArgs {
+		Dom: Dom,
+		User: User,
+		Keys: Keys,
+		Flags: Flags,
+	}
+
+	buf, err = encode(&args)
+	if err != nil {
+		return
+	}
+
+
+	_, err = l.requestStream(425, constants.Program, buf, nil, nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
diff --git a/vendor/github.com/digitalocean/go-libvirt/rpc.go b/vendor/github.com/digitalocean/go-libvirt/rpc.go
new file mode 100644
index 000000000..8181e0991
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/rpc.go
@@ -0,0 +1,606 @@
+// Copyright 2018 The go-libvirt Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package libvirt
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"reflect"
+	"strings"
+	"sync/atomic"
+	"unsafe"
+
+	"github.com/digitalocean/go-libvirt/internal/constants"
+	"github.com/digitalocean/go-libvirt/internal/event"
+	xdr "github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2"
+)
+
+// ErrUnsupported is returned if a procedure is not supported by libvirt
+var ErrUnsupported = errors.New("unsupported procedure requested")
+
+// request and response types
+const (
+	// Call is used when making calls to the remote server.
+	Call = iota
+
+	// Reply indicates a server reply.
+	Reply
+
+	// Message is an asynchronous notification.
+	Message
+
+	// Stream represents a stream data packet.
+	Stream
+
+	// CallWithFDs is used by a client to indicate the request has
+	// arguments with file descriptors.
+	CallWithFDs
+
+	// ReplyWithFDs is used by a server to indicate the request has
+	// arguments with file descriptors.
+	ReplyWithFDs
+)
+
+// request and response statuses
+const (
+	// StatusOK is always set for method calls or events.
+	// For replies it indicates successful completion of the method.
+	// For streams it indicates confirmation of the end of file on the stream.
+	StatusOK = iota
+
+	// StatusError for replies indicates that the method call failed
+	// and error information is being returned. For streams this indicates
+	// that not all data was sent and the stream has aborted.
+	StatusError
+
+	// StatusContinue is only used for streams.
+	// This indicates that further data packets will be following.
+	StatusContinue
+)
+
+// header is a libvirt rpc packet header
+type header struct {
+	// Program identifier
+	Program uint32
+
+	// Program version
+	Version uint32
+
+	// Remote procedure identifier
+	Procedure uint32
+
+	// Call type, e.g., Reply
+	Type uint32
+
+	// Call serial number
+	Serial int32
+
+	// Request status, e.g., StatusOK
+	Status uint32
+}
+
+// packet represents a RPC request or response.
+type packet struct {
+	// Size of packet, in bytes, including length.
+	// Len + Header + Payload
+	Len    uint32
+	Header header
+}
+
+// Global packet instance, for use with unsafe.Sizeof()
+var _p packet
+
+// internal rpc response
+type response struct {
+	Payload []byte
+	Status  uint32
+}
+
+// libvirt error response
+type libvirtError struct {
+	Code     uint32
+	DomainID uint32
+	Padding  uint8
+	Message  string
+	Level    uint32
+}
+
+func (e libvirtError) Error() string {
+	return e.Message
+}
+
+// checkError is used to check whether an error is a libvirtError, and if it is,
+// whether its error code matches the one passed in. It will return false if
+// these conditions are not met.
+func checkError(err error, expectedError errorNumber) bool {
+	e, ok := err.(libvirtError)
+	if ok {
+		return e.Code == uint32(expectedError)
+	}
+	return false
+}
+
+// IsNotFound detects libvirt's ERR_NO_DOMAIN.
+func IsNotFound(err error) bool {
+	return checkError(err, errNoDomain)
+}
+
+// listen processes incoming data and routes
+// responses to their respective callback handler.
+func (l *Libvirt) listen() {
+	for {
+		// response packet length
+		length, err := pktlen(l.r)
+		if err != nil {
+			// When the underlying connection EOFs or is closed, stop
+			// this goroutine
+			if err == io.EOF || strings.Contains(err.Error(), "use of closed network connection") {
+				return
+			}
+
+			// invalid packet
+			continue
+		}
+
+		// response header
+		h, err := extractHeader(l.r)
+		if err != nil {
+			// invalid packet
+			continue
+		}
+
+		// payload: packet length minus what was previously read
+		size := int(length) - int(unsafe.Sizeof(_p))
+		buf := make([]byte, size)
+		_, err = io.ReadFull(l.r, buf)
+		if err != nil {
+			// invalid packet
+			continue
+		}
+
+		// route response to caller
+		l.route(h, buf)
+	}
+}
+
+// callback sends RPC responses to respective callers.
+func (l *Libvirt) callback(id int32, res response) {
+	l.cmux.Lock()
+	defer l.cmux.Unlock()
+
+	c, ok := l.callbacks[id]
+	if !ok {
+		return
+	}
+
+	c <- res
+}
+
+// route sends incoming packets to their listeners.
+func (l *Libvirt) route(h *header, buf []byte) {
+	// route events to their respective listener
+	var event event.Event
+
+	switch {
+	case h.Program == constants.QEMUProgram && h.Procedure == constants.QEMUProcDomainMonitorEvent:
+		event = &DomainEvent{}
+	case h.Program == constants.Program && h.Procedure == constants.ProcDomainEventCallbackLifecycle:
+		event = &DomainEventCallbackLifecycleMsg{}
+	}
+
+	if event != nil {
+		err := eventDecoder(buf, event)
+		if err != nil { // event was malformed, drop.
+			return
+		}
+
+		l.stream(event)
+		return
+	}
+
+	// send response to caller
+	l.callback(h.Serial, response{Payload: buf, Status: h.Status})
+}
+
+// serial provides atomic access to the next sequential request serial number.
+func (l *Libvirt) serial() int32 {
+	return atomic.AddInt32(&l.s, 1)
+}
+
+// stream decodes and relays domain events to their respective listener.
+func (l *Libvirt) stream(e event.Event) {
+	l.emux.RLock()
+	defer l.emux.RUnlock()
+
+	q, ok := l.events[e.GetCallbackID()]
+	if !ok {
+		return
+	}
+
+	q.Push(e)
+}
+
+// addStream configures the routing for an event stream.
+func (l *Libvirt) addStream(s *event.Stream) {
+	l.emux.Lock()
+	defer l.emux.Unlock()
+
+	l.events[s.CallbackID] = s
+}
+
+// removeStream notifies the libvirt server to stop sending events for the
+// provided callback ID. Upon successful de-registration the callback handler
+// is destroyed. Subsequent calls to removeStream are idempotent and return
+// nil.
+// TODO: Fix this comment
+func (l *Libvirt) removeStream(id int32) error {
+	l.emux.Lock()
+	defer l.emux.Unlock()
+
+	// if the event is already removed, just return nil
+	_, ok := l.events[id]
+	if ok {
+		delete(l.events, id)
+	}
+
+	return nil
+}
+
+// register configures a method response callback
+func (l *Libvirt) register(id int32, c chan response) {
+	l.cmux.Lock()
+	defer l.cmux.Unlock()
+
+	l.callbacks[id] = c
+}
+
+// deregister destroys a method response callback. It is the responsibility of
+// the caller to manage locking (l.cmux) during this call.
+func (l *Libvirt) deregister(id int32) {
+	_, ok := l.callbacks[id]
+	if !ok {
+		return
+	}
+
+	close(l.callbacks[id])
+	delete(l.callbacks, id)
+}
+
+// deregisterAll closes all waiting callback channels. This is used to clean up
+// if the connection to libvirt is lost. Callers waiting for responses will
+// return an error when the response channel is closed, rather than just
+// hanging.
+func (l *Libvirt) deregisterAll() {
+	l.cmux.Lock()
+	defer l.cmux.Unlock()
+
+	for id := range l.callbacks {
+		l.deregister(id)
+	}
+}
+
+// request performs a libvirt RPC request.
+// returns response returned by server.
+// if response is not OK, decodes error from it and returns it.
+func (l *Libvirt) request(proc uint32, program uint32, payload []byte) (response, error) {
+	return l.requestStream(proc, program, payload, nil, nil)
+}
+
+// requestStream performs a libvirt RPC request. The `out` and `in` parameters
+// are optional, and should be nil when RPC endpoints don't return a stream.
+func (l *Libvirt) requestStream(proc uint32, program uint32, payload []byte,
+	out io.Reader, in io.Writer) (response, error) {
+	serial := l.serial()
+	c := make(chan response)
+
+	l.register(serial, c)
+	defer func() {
+		l.cmux.Lock()
+		defer l.cmux.Unlock()
+
+		l.deregister(serial)
+	}()
+
+	err := l.sendPacket(serial, proc, program, payload, Call, StatusOK)
+	if err != nil {
+		return response{}, err
+	}
+
+	resp, err := l.getResponse(c)
+	if err != nil {
+		return resp, err
+	}
+
+	if out != nil {
+		abort := make(chan bool)
+		outErr := make(chan error)
+		go func() {
+			outErr <- l.sendStream(serial, proc, program, out, abort)
+		}()
+
+		// Even without incoming stream server sends confirmation once all data is received
+		resp, err = l.processIncomingStream(c, in)
+		if err != nil {
+			abort <- true
+			return resp, err
+		}
+
+		err = <-outErr
+		if err != nil {
+			return response{}, err
+		}
+	}
+
+	switch in {
+	case nil:
+		return resp, nil
+	default:
+		return l.processIncomingStream(c, in)
+	}
+}
+
+// processIncomingStream is called once we've successfully sent a request to
+// libvirt. It writes the responses back to the stream passed by the caller
+// until libvirt sends a packet with statusOK or an error.
+func (l *Libvirt) processIncomingStream(c chan response, inStream io.Writer) (response, error) {
+	for {
+		resp, err := l.getResponse(c)
+		if err != nil {
+			return resp, err
+		}
+
+		// StatusOK indicates end of stream
+		if resp.Status == StatusOK {
+			return resp, nil
+		}
+
+		// FIXME: this smells.
+		// StatusError is handled in getResponse, so this must be StatusContinue
+		// StatusContinue is only valid here for stream packets
+		// libvirtd breaks protocol and returns StatusContinue with an
+		// empty response Payload when the stream finishes
+		if len(resp.Payload) == 0 {
+			return resp, nil
+		}
+		if inStream != nil {
+			_, err = inStream.Write(resp.Payload)
+			if err != nil {
+				return response{}, err
+			}
+		}
+	}
+}
+
+func (l *Libvirt) sendStream(serial int32, proc uint32, program uint32, stream io.Reader, abort chan bool) error {
+	// Keep total packet length under 4 MiB to follow possible limitation in libvirt server code
+	buf := make([]byte, 4*MiB-unsafe.Sizeof(_p))
+	for {
+		select {
+		case <-abort:
+			return l.sendPacket(serial, proc, program, nil, Stream, StatusError)
+		default:
+		}
+		n, err := stream.Read(buf)
+		if n > 0 {
+			err2 := l.sendPacket(serial, proc, program, buf[:n], Stream, StatusContinue)
+			if err2 != nil {
+				return err2
+			}
+		}
+		if err != nil {
+			if err == io.EOF {
+				return l.sendPacket(serial, proc, program, nil, Stream, StatusOK)
+			}
+			// keep original error
+			err2 := l.sendPacket(serial, proc, program, nil, Stream, StatusError)
+			if err2 != nil {
+				return err2
+			}
+			return err
+		}
+	}
+}
+
+func (l *Libvirt) sendPacket(serial int32, proc uint32, program uint32, payload []byte, typ uint32, status uint32) error {
+
+	p := packet{
+		Header: header{
+			Program:   program,
+			Version:   constants.ProtocolVersion,
+			Procedure: proc,
+			Type:      typ,
+			Serial:    serial,
+			Status:    status,
+		},
+	}
+
+	size := int(unsafe.Sizeof(p.Len)) + int(unsafe.Sizeof(p.Header))
+	if payload != nil {
+		size += len(payload)
+	}
+	p.Len = uint32(size)
+
+	// write header
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	err := binary.Write(l.w, binary.BigEndian, p)
+	if err != nil {
+		return err
+	}
+
+	// write payload
+	if payload != nil {
+		err = binary.Write(l.w, binary.BigEndian, payload)
+		if err != nil {
+			return err
+		}
+	}
+
+	return l.w.Flush()
+}
+
+func (l *Libvirt) getResponse(c chan response) (response, error) {
+	resp := <-c
+	if resp.Status == StatusError {
+		return resp, decodeError(resp.Payload)
+	}
+
+	return resp, nil
+}
+
+// encode XDR encodes the provided data.
+func encode(data interface{}) ([]byte, error) {
+	var buf bytes.Buffer
+	_, err := xdr.Marshal(&buf, data)
+
+	return buf.Bytes(), err
+}
+
+// decodeError extracts an error message from the provider buffer.
+func decodeError(buf []byte) error {
+	var e libvirtError
+
+	dec := xdr.NewDecoder(bytes.NewReader(buf))
+	_, err := dec.Decode(&e)
+	if err != nil {
+		return err
+	}
+
+	if strings.Contains(e.Message, "unknown procedure") {
+		return ErrUnsupported
+	}
+	// if libvirt returns ERR_OK, ignore the error
+	if checkError(e, errOk) {
+		return nil
+	}
+
+	return e
+}
+
+// eventDecoder decodes an event from a xdr buffer.
+func eventDecoder(buf []byte, e interface{}) error {
+	dec := xdr.NewDecoder(bytes.NewReader(buf))
+	_, err := dec.Decode(e)
+	return err
+}
+
+// pktlen returns the length of an incoming RPC packet.  Read errors will
+// result in a returned response length of 0 and a non-nil error.
+func pktlen(r io.Reader) (uint32, error) {
+	buf := make([]byte, unsafe.Sizeof(_p.Len))
+
+	// extract the packet's length from the header
+	_, err := io.ReadFull(r, buf)
+	if err != nil {
+		return 0, err
+	}
+
+	return binary.BigEndian.Uint32(buf), nil
+}
+
+// extractHeader returns the decoded header from an incoming response.
+func extractHeader(r io.Reader) (*header, error) {
+	buf := make([]byte, unsafe.Sizeof(_p.Header))
+
+	// extract the packet's header from r
+	_, err := io.ReadFull(r, buf)
+	if err != nil {
+		return nil, err
+	}
+
+	return &header{
+		Program:   binary.BigEndian.Uint32(buf[0:4]),
+		Version:   binary.BigEndian.Uint32(buf[4:8]),
+		Procedure: binary.BigEndian.Uint32(buf[8:12]),
+		Type:      binary.BigEndian.Uint32(buf[12:16]),
+		Serial:    int32(binary.BigEndian.Uint32(buf[16:20])),
+		Status:    binary.BigEndian.Uint32(buf[20:24]),
+	}, nil
+}
+
+type typedParamDecoder struct{}
+
+// Decode decodes a TypedParam. These are part of the libvirt spec, and not xdr
+// proper. TypedParams contain a name, which is called Field for some reason,
+// and a Value, which itself has a "discriminant" - an integer enum encoding the
+// actual type, and a value, the length of which varies based on the actual
+// type.
+func (tpd typedParamDecoder) Decode(d *xdr.Decoder, v reflect.Value) (int, error) {
+	// Get the name of the typed param first
+	name, n, err := d.DecodeString()
+	if err != nil {
+		return n, err
+	}
+	val, n2, err := tpd.decodeTypedParamValue(d)
+	n += n2
+	if err != nil {
+		return n, err
+	}
+	tp := &TypedParam{Field: name, Value: *val}
+	v.Set(reflect.ValueOf(*tp))
+
+	return n, nil
+}
+
+// decodeTypedParamValue decodes the Value part of a TypedParam.
+func (typedParamDecoder) decodeTypedParamValue(d *xdr.Decoder) (*TypedParamValue, int, error) {
+	// All TypedParamValues begin with a uint32 discriminant that tells us what
+	// type they are.
+	discriminant, n, err := d.DecodeUint()
+	if err != nil {
+		return nil, n, err
+	}
+	var n2 int
+	var tpv *TypedParamValue
+	switch discriminant {
+	case 1:
+		var val int32
+		n2, err = d.Decode(&val)
+		tpv = &TypedParamValue{D: discriminant, I: val}
+	case 2:
+		var val uint32
+		n2, err = d.Decode(&val)
+		tpv = &TypedParamValue{D: discriminant, I: val}
+	case 3:
+		var val int64
+		n2, err = d.Decode(&val)
+		tpv = &TypedParamValue{D: discriminant, I: val}
+	case 4:
+		var val uint64
+		n2, err = d.Decode(&val)
+		tpv = &TypedParamValue{D: discriminant, I: val}
+	case 5:
+		var val float64
+		n2, err = d.Decode(&val)
+		tpv = &TypedParamValue{D: discriminant, I: val}
+	case 6:
+		var val int32
+		n2, err = d.Decode(&val)
+		tpv = &TypedParamValue{D: discriminant, I: val}
+	case 7:
+		var val string
+		n2, err = d.Decode(&val)
+		tpv = &TypedParamValue{D: discriminant, I: val}
+
+	default:
+		err = fmt.Errorf("invalid parameter type %v", discriminant)
+	}
+	n += n2
+
+	return tpv, n, err
+}
diff --git a/vendor/github.com/digitalocean/go-libvirt/units.go b/vendor/github.com/digitalocean/go-libvirt/units.go
new file mode 100644
index 000000000..03686507f
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-libvirt/units.go
@@ -0,0 +1,27 @@
+// Copyright 2016 The go-libvirt Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This module provides different units of measurement to make other
+// code more readable.
+
+package libvirt
+
+const (
+    // B - byte
+	B   = 1
+    // KiB - kibibyte
+	KiB = 1024 * B
+    // MiB - mebibyte
+	MiB = 1024 * KiB
+)
diff --git a/vendor/github.com/digitalocean/go-qemu/AUTHORS b/vendor/github.com/digitalocean/go-qemu/AUTHORS
new file mode 100644
index 000000000..e2836c3c7
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-qemu/AUTHORS
@@ -0,0 +1,17 @@
+Maintainer
+----------
+DigitalOcean, Inc
+
+Original Authors
+----------------
+Ben LeMasurier	<blemasurier@digitalocean.com>
+Matt Layher	<mlayher@digitalocean.com>
+
+Contributors
+------------
+David Anderson  <dave@natulte.net>
+Justin Kim      <justin@digitalocean.com>
+Luis Sagastume  <lsagastume1990@gmail.com>
+Nedim Dedic     <nedim_dedic@yahoo.com>
+Roberto J Rojas <robertojrojas@gmail.com>
+Marko Mudrinic  <mudrinic.mare@gmail.com>
diff --git a/vendor/github.com/digitalocean/go-qemu/LICENSE.md b/vendor/github.com/digitalocean/go-qemu/LICENSE.md
new file mode 100644
index 000000000..f5f4b8b5e
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-qemu/LICENSE.md
@@ -0,0 +1,195 @@
+Apache License
+==============
+
+_Version 2.0, January 2004_  
+_&lt;<http://www.apache.org/licenses/>&gt;_
+
+### Terms and Conditions for use, reproduction, and distribution
+
+#### 1. Definitions
+
+“License” shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+“Licensor” shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+“Legal Entity” shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, “control” means **(i)** the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or **(ii)** ownership of fifty percent (50%) or more of the
+outstanding shares, or **(iii)** beneficial ownership of such entity.
+
+“You” (or “Your”) shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+“Source” form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+“Object” form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+“Work” shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+“Derivative Works” shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+“Contribution” shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+“submitted” means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as “Not a Contribution.”
+
+“Contributor” shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+#### 2. Grant of Copyright License
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+#### 3. Grant of Patent License
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+#### 4. Redistribution
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+* **(a)** You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+* **(b)** You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+* **(c)** You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+* **(d)** If the Work includes a “NOTICE” text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+#### 5. Submission of Contributions
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+#### 6. Trademarks
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+#### 7. Disclaimer of Warranty
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an “AS IS” BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+#### 8. Limitation of Liability
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+#### 9. Accepting Warranty or Additional Liability
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+_END OF TERMS AND CONDITIONS_
+
+### APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets `[]` replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same “printed page” as the copyright notice for easier identification within
+third-party archives.
+
+    Copyright [yyyy] [name of copyright owner]
+    
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+    
+      http://www.apache.org/licenses/LICENSE-2.0
+    
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
diff --git a/vendor/github.com/digitalocean/go-qemu/qmp/README.md b/vendor/github.com/digitalocean/go-qemu/qmp/README.md
new file mode 100644
index 000000000..729280b31
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-qemu/qmp/README.md
@@ -0,0 +1,104 @@
+QMP
+===
+
+Package `qmp` enables interaction with QEMU instances via the QEMU Machine Protocol (QMP).
+
+## Available Drivers
+
+### Libvirt
+
+If your environment is managed by Libvirt, QMP interaction must be proxied through the Libvirt daemon. This can be be done through two available drivers:
+
+#### RPC
+
+The RPC driver provides a pure Go implementation of Libvirt's RPC protocol.
+
+```go
+//conn, err := net.DialTimeout("unix", "/var/run/libvirt/libvirt-sock", 2*time.Second)
+conn, err := net.DialTimeout("tcp", "192.168.1.1:16509", 2*time.Second)
+monitor := libvirtrpc.New("stage-lb-1", conn)
+```
+
+#### virsh
+
+A connection to the monitor socket is provided by proxing requests through the `virsh` executable.
+
+```go
+monitor, err := qmp.NewLibvirtMonitor("qemu:///system", "stage-lb-1")
+```
+
+### Socket
+
+If your QEMU instances are not managed by libvirt, direct communication over its UNIX socket is available.
+
+```go
+monitor, err := qmp.NewSocketMonitor("unix", "/var/lib/qemu/example.monitor", 2*time.Second)
+```
+
+## Examples
+
+Using the above to establish a new `qmp.Monitor`, the following examples provide a brief overview of QMP usage.
+
+_error checking omitted for the sake of brevity._
+
+### Command Execution
+```go
+type StatusResult struct {
+	ID     string `json:"id"`
+	Return struct {
+		Running    bool   `json:"running"`
+		Singlestep bool   `json:"singlestep"`
+		Status     string `json:"status"`
+	} `json:"return"`
+}
+
+monitor.Connect()
+defer monitor.Disconnect()
+
+cmd := []byte(`{ "execute": "query-status" }`)
+raw, _ := monitor.Run(cmd)
+
+var result StatusResult
+json.Unmarshal(raw, &result)
+
+fmt.Println(result.Return.Status)
+```
+
+```
+running
+```
+
+### Event Monitor
+
+```go
+monitor.Connect()
+defer monitor.Disconnect()
+
+stream, _ := monitor.Events()
+for e := range stream {
+	log.Printf("EVENT: %s", e.Event)
+}
+
+```
+
+```
+$ virsh reboot example
+Domain example is being rebooted
+```
+
+```
+EVENT: POWERDOWN
+EVENT: SHUTDOWN
+EVENT: STOP
+EVENT: RESET
+EVENT: RESUME
+EVENT: RESET
+...
+```
+
+## More information
+
+* [QEMU QMP Wiki](http://wiki.qemu.org/QMP)
+* [QEMU QMP Intro](http://git.qemu.org/?p=qemu.git;a=blob_plain;f=docs/qmp-intro.txt;hb=HEAD)
+* [QEMU QMP Events](http://git.qemu.org/?p=qemu.git;a=blob_plain;f=docs/qmp-events.txt;hb=HEAD)
+* [QEMU QMP Spec](http://git.qemu.org/?p=qemu.git;a=blob_plain;f=docs/qmp-spec.txt;hb=HEAD)
diff --git a/vendor/github.com/digitalocean/go-qemu/qmp/qmp.go b/vendor/github.com/digitalocean/go-qemu/qmp/qmp.go
new file mode 100644
index 000000000..b856260d3
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-qemu/qmp/qmp.go
@@ -0,0 +1,94 @@
+// Copyright 2016 The go-qemu Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package qmp enables interaction with QEMU instances
+// via the QEMU Machine Protocol (QMP).
+package qmp
+
+import (
+	"context"
+	"errors"
+	"fmt"
+)
+
+// ErrEventsNotSupported is returned by Events() if event streams
+// are unsupported by either QEMU or libvirt.
+var ErrEventsNotSupported = errors.New("event monitor is not supported")
+
+// Monitor represents a QEMU Machine Protocol socket.
+// See: http://wiki.qemu.org/QMP
+type Monitor interface {
+	Connect() error
+	Disconnect() error
+	Run(command []byte) (out []byte, err error)
+	Events(context.Context) (events <-chan Event, err error)
+}
+
+// Command represents a QMP command.
+type Command struct {
+	// Name of the command to run
+	Execute string `json:"execute"`
+
+	// Optional arguments for the above command.
+	Args interface{} `json:"arguments,omitempty"`
+}
+
+type response struct {
+	ID     string      `json:"id"`
+	Return interface{} `json:"return,omitempty"`
+	Error  struct {
+		Class string `json:"class"`
+		Desc  string `json:"desc"`
+	} `json:"error,omitempty"`
+}
+
+func (r *response) Err() error {
+	if r.Error.Desc == "" {
+		return nil
+	}
+
+	return errors.New(r.Error.Desc)
+}
+
+// Event represents a QEMU QMP event.
+// See http://wiki.qemu.org/QMP
+type Event struct {
+	// Event name, e.g., BLOCK_JOB_COMPLETE
+	Event string `json:"event"`
+
+	// Arbitrary event data
+	Data map[string]interface{} `json:"data"`
+
+	// Event timestamp, provided by QEMU.
+	Timestamp struct {
+		Seconds      int64 `json:"seconds"`
+		Microseconds int64 `json:"microseconds"`
+	} `json:"timestamp"`
+}
+
+// Version is the QEMU version structure returned when a QMP connection is
+// initiated.
+type Version struct {
+	Package string `json:"package"`
+	QEMU    struct {
+		Major int `json:"major"`
+		Micro int `json:"micro"`
+		Minor int `json:"minor"`
+	} `json:"qemu"`
+}
+
+func (v Version) String() string {
+	q := v.QEMU
+	return fmt.Sprintf("%d.%d.%d", q.Major, q.Minor, q.Micro)
+}
diff --git a/vendor/github.com/digitalocean/go-qemu/qmp/rpc.go b/vendor/github.com/digitalocean/go-qemu/qmp/rpc.go
new file mode 100644
index 000000000..cb11c71fe
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-qemu/qmp/rpc.go
@@ -0,0 +1,107 @@
+// Copyright 2016 The go-qemu Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package qmp
+
+import (
+	"context"
+	"encoding/json"
+	"net"
+
+	"github.com/digitalocean/go-libvirt"
+)
+
+var _ Monitor = &LibvirtRPCMonitor{}
+
+// A LibvirtRPCMonitor implements LibVirt's remote procedure call protocol.
+type LibvirtRPCMonitor struct {
+	l *libvirt.Libvirt
+	// Domain name as seen by libvirt, e.g., stage-lb-1
+	Domain string
+}
+
+// NewLibvirtRPCMonitor configures a new Libvirt RPC Monitor connection.
+// The provided domain should be the name of the domain as seen
+// by libvirt, e.g., stage-lb-1.
+func NewLibvirtRPCMonitor(domain string, conn net.Conn) *LibvirtRPCMonitor {
+	l := libvirt.New(conn)
+
+	return &LibvirtRPCMonitor{
+		l:      l,
+		Domain: domain,
+	}
+}
+
+// Connect establishes communication with the libvirt server.
+// The underlying libvirt socket connection must be previously established.
+func (rpc *LibvirtRPCMonitor) Connect() error {
+	return rpc.l.Connect()
+}
+
+// Disconnect shuts down communication with the libvirt server
+// and closes the underlying net.Conn.
+func (rpc *LibvirtRPCMonitor) Disconnect() error {
+	return rpc.l.Disconnect()
+}
+
+// Events streams QEMU QMP Events until the provided context is cancelled.
+// If a problem is encountered setting up the event monitor connection
+// an error will be returned. Errors encountered during streaming will
+// cause the returned event channel to be closed.
+func (rpc *LibvirtRPCMonitor) Events(ctx context.Context) (<-chan Event, error) {
+	events, err := rpc.l.SubscribeQEMUEvents(ctx, rpc.Domain)
+	if err != nil {
+		return nil, err
+	}
+
+	c := make(chan Event)
+	go func() {
+		// process events
+		for e := range events {
+			qe, err := qmpEvent(&e)
+			if err != nil {
+				close(c)
+				break
+			}
+
+			c <- *qe
+		}
+	}()
+
+	return c, nil
+}
+
+// Run executes the given QAPI command against a domain's QEMU instance.
+// For a list of available QAPI commands, see:
+//	http://git.qemu.org/?p=qemu.git;a=blob;f=qapi-schema.json;hb=HEAD
+func (rpc *LibvirtRPCMonitor) Run(cmd []byte) ([]byte, error) {
+	return rpc.l.Run(rpc.Domain, cmd)
+}
+
+// qmpEvent takes a libvirt DomainEvent and returns the QMP equivalent.
+func qmpEvent(e *libvirt.DomainEvent) (*Event, error) {
+	var qe Event
+
+	if e.Details != nil {
+		if err := json.Unmarshal(e.Details, &qe.Data); err != nil {
+			return nil, err
+		}
+	}
+
+	qe.Event = e.Event
+	qe.Timestamp.Seconds = int64(e.Seconds)
+	qe.Timestamp.Microseconds = int64(e.Microseconds)
+
+	return &qe, nil
+}
diff --git a/vendor/github.com/digitalocean/go-qemu/qmp/socket.go b/vendor/github.com/digitalocean/go-qemu/qmp/socket.go
new file mode 100644
index 000000000..541a88676
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-qemu/qmp/socket.go
@@ -0,0 +1,274 @@
+// Copyright 2016 The go-qemu Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package qmp
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net"
+	"os"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+// A SocketMonitor is a Monitor which speaks directly to a QEMU Machine Protocol
+// (QMP) socket. Communication is performed directly using a QEMU monitor socket,
+// typically using a UNIX socket or TCP connection.  Multiple connections to the
+// same domain are not permitted, and will result in the monitor blocking until
+// the existing connection is closed.
+type SocketMonitor struct {
+	// QEMU version reported by a connected monitor socket.
+	Version *Version
+
+	// QEMU QMP capabiltiies reported by a connected monitor socket.
+	Capabilities []string
+
+	// Underlying connection
+	c net.Conn
+
+	// Serialize running command against domain
+	mu sync.Mutex
+
+	// Send command responses and errors
+	stream <-chan streamResponse
+
+	// Send domain events to listeners when available
+	listeners *int32
+	events    <-chan Event
+}
+
+// NewSocketMonitor configures a connection to the provided QEMU monitor socket.
+// An error is returned if the socket cannot be successfully dialed, or the
+// dial attempt times out.
+//
+// NewSocketMonitor may dial the QEMU socket using a variety of connection types:
+//	NewSocketMonitor("unix", "/var/lib/qemu/example.monitor", 2 * time.Second)
+//	NewSocketMonitor("tcp", "8.8.8.8:4444", 2 * time.Second)
+func NewSocketMonitor(network, addr string, timeout time.Duration) (*SocketMonitor, error) {
+	c, err := net.DialTimeout(network, addr, timeout)
+	if err != nil {
+		return nil, err
+	}
+
+	mon := &SocketMonitor{
+		c:         c,
+		listeners: new(int32),
+	}
+
+	return mon, nil
+}
+
+// Listen creates a new SocketMonitor listening for a single connection to the provided socket file or address.
+// An error is returned if unable to listen at the specified file path or port.
+//
+// Listen will wait for a QEMU socket connection using a variety connection types:
+//	Listen("unix", "/var/lib/qemu/example.monitor")
+//	Listen("tcp", "0.0.0.0:4444")
+func Listen(network, addr string) (*SocketMonitor, error) {
+	l, err := net.Listen(network, addr)
+	if err != nil {
+		return nil, err
+	}
+	c, err := l.Accept()
+	defer l.Close()
+	if err != nil {
+		return nil, err
+	}
+
+	mon := &SocketMonitor{
+		c:         c,
+		listeners: new(int32),
+	}
+
+	return mon, nil
+}
+
+// Disconnect closes the QEMU monitor socket connection.
+func (mon *SocketMonitor) Disconnect() error {
+	atomic.StoreInt32(mon.listeners, 0)
+	err := mon.c.Close()
+
+	return err
+}
+
+// qmpCapabilities is the command which must be executed to perform the
+// QEMU QMP handshake.
+const qmpCapabilities = "qmp_capabilities"
+
+// Connect sets up a QEMU QMP connection by connecting directly to the QEMU
+// monitor socket.  An error is returned if the capabilities handshake does
+// not succeed.
+func (mon *SocketMonitor) Connect() error {
+	enc := json.NewEncoder(mon.c)
+	dec := json.NewDecoder(mon.c)
+
+	// Check for banner on startup
+	var ban banner
+	if err := dec.Decode(&ban); err != nil {
+		return err
+	}
+	mon.Version = &ban.QMP.Version
+	mon.Capabilities = ban.QMP.Capabilities
+
+	// Issue capabilities handshake
+	cmd := Command{Execute: qmpCapabilities}
+	if err := enc.Encode(cmd); err != nil {
+		return err
+	}
+
+	// Check for no error on return
+	var r response
+	if err := dec.Decode(&r); err != nil {
+		return err
+	}
+	if err := r.Err(); err != nil {
+		return err
+	}
+
+	// Initialize socket listener for command responses and asynchronous
+	// events
+	events := make(chan Event)
+	stream := make(chan streamResponse)
+	go mon.listen(mon.c, events, stream)
+
+	mon.events = events
+	mon.stream = stream
+
+	return nil
+}
+
+// Events streams QEMU QMP Events.
+// Events should only be called once per Socket.  If used with a qemu.Domain,
+// qemu.Domain.Events should be called to retrieve events instead.
+func (mon *SocketMonitor) Events(context.Context) (<-chan Event, error) {
+	atomic.AddInt32(mon.listeners, 1)
+	return mon.events, nil
+}
+
+// listen listens for incoming data from a QEMU monitor socket.  It determines
+// if the data is an asynchronous event or a response to a command, and returns
+// the data on the appropriate channel.
+func (mon *SocketMonitor) listen(r io.Reader, events chan<- Event, stream chan<- streamResponse) {
+	defer close(events)
+	defer close(stream)
+
+	scanner := bufio.NewScanner(r)
+	for scanner.Scan() {
+		var e Event
+
+		b := scanner.Bytes()
+		if err := json.Unmarshal(b, &e); err != nil {
+			continue
+		}
+
+		// If data does not have an event type, it must be in response to a command.
+		if e.Event == "" {
+			stream <- streamResponse{buf: b}
+			continue
+		}
+
+		// If nobody is listening for events, do not bother sending them.
+		if atomic.LoadInt32(mon.listeners) == 0 {
+			continue
+		}
+
+		events <- e
+	}
+
+	if err := scanner.Err(); err != nil {
+		stream <- streamResponse{err: err}
+	}
+}
+
+// Run executes the given QAPI command against a domain's QEMU instance.
+// For a list of available QAPI commands, see:
+//	http://git.qemu.org/?p=qemu.git;a=blob;f=qapi-schema.json;hb=HEAD
+func (mon *SocketMonitor) Run(command []byte) ([]byte, error) {
+	// Just call RunWithFile with no file
+	return mon.RunWithFile(command, nil)
+}
+
+// RunWithFile behaves like Run but allows for passing a file through out-of-band data.
+func (mon *SocketMonitor) RunWithFile(command []byte, file *os.File) ([]byte, error) {
+	// Only allow a single command to be run at a time to ensure that responses
+	// to a command cannot be mixed with responses from another command
+	mon.mu.Lock()
+	defer mon.mu.Unlock()
+
+	if file == nil {
+		// Just send a normal command through.
+		if _, err := mon.c.Write(command); err != nil {
+			return nil, err
+		}
+	} else {
+		unixConn, ok := mon.c.(*net.UnixConn)
+		if !ok {
+			return nil, fmt.Errorf("RunWithFile only works with unix monitor sockets")
+		}
+
+		oobSupported := false
+		for _, capability := range mon.Capabilities {
+			if capability == "oob" {
+				oobSupported = true
+				break
+			}
+		}
+
+		if !oobSupported {
+			return nil, fmt.Errorf("The QEMU server doesn't support oob (needed for RunWithFile)")
+		}
+
+		// Send the command along with the file descriptor.
+		oob := getUnixRights(file)
+		if _, _, err := unixConn.WriteMsgUnix(command, oob, nil); err != nil {
+			return nil, err
+		}
+	}
+
+	// Wait for a response or error to our command
+	res := <-mon.stream
+	if res.err != nil {
+		return nil, res.err
+	}
+
+	// Check for QEMU errors
+	var r response
+	if err := json.Unmarshal(res.buf, &r); err != nil {
+		return nil, err
+	}
+	if err := r.Err(); err != nil {
+		return nil, err
+	}
+
+	return res.buf, nil
+}
+
+// banner is a wrapper type around a Version.
+type banner struct {
+	QMP struct {
+		Capabilities []string `json:"capabilities"`
+		Version Version `json:"version"`
+	} `json:"QMP"`
+}
+
+// streamResponse is a struct sent over a channel in response to a command.
+type streamResponse struct {
+	buf []byte
+	err error
+}
diff --git a/vendor/github.com/digitalocean/go-qemu/qmp/socket_unix.go b/vendor/github.com/digitalocean/go-qemu/qmp/socket_unix.go
new file mode 100644
index 000000000..859ff64ea
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-qemu/qmp/socket_unix.go
@@ -0,0 +1,27 @@
+// Copyright 2016 The go-qemu Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build !windows
+
+package qmp
+
+import (
+	"os"
+
+	"golang.org/x/sys/unix"
+)
+
+func getUnixRights(file *os.File) []byte {
+	return unix.UnixRights(int(file.Fd()))
+}
diff --git a/vendor/github.com/digitalocean/go-qemu/qmp/socket_windows.go b/vendor/github.com/digitalocean/go-qemu/qmp/socket_windows.go
new file mode 100644
index 000000000..b8a611dbf
--- /dev/null
+++ b/vendor/github.com/digitalocean/go-qemu/qmp/socket_windows.go
@@ -0,0 +1,25 @@
+// Copyright 2016 The go-qemu Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build windows
+
+package qmp
+
+import (
+	"os"
+)
+
+func getUnixRights(file *os.File) []byte {
+	return nil
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/.gitignore b/vendor/github.com/vbauerster/mpb/v6/.gitignore
new file mode 100644
index 000000000..63bd91672
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/.gitignore
@@ -0,0 +1,5 @@
+# Test binary, build with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
diff --git a/vendor/github.com/vbauerster/mpb/v6/.travis.yml b/vendor/github.com/vbauerster/mpb/v6/.travis.yml
new file mode 100644
index 000000000..9a203a67d
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/.travis.yml
@@ -0,0 +1,11 @@
+language: go
+arch:
+  - amd64
+  - ppc64le
+
+go:
+  - 1.14.x
+
+script:
+  - go test -race ./...
+  - for i in _examples/*/; do go build $i/*.go || exit 1; done
diff --git a/vendor/github.com/vbauerster/mpb/v6/README.md b/vendor/github.com/vbauerster/mpb/v6/README.md
new file mode 100644
index 000000000..a87786d72
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/README.md
@@ -0,0 +1,120 @@
+# Multi Progress Bar
+
+[![GoDoc](https://pkg.go.dev/badge/github.com/vbauerster/mpb)](https://pkg.go.dev/github.com/vbauerster/mpb/v6)
+[![Build Status](https://travis-ci.org/vbauerster/mpb.svg?branch=master)](https://travis-ci.org/vbauerster/mpb)
+[![Go Report Card](https://goreportcard.com/badge/github.com/vbauerster/mpb)](https://goreportcard.com/report/github.com/vbauerster/mpb)
+
+**mpb** is a Go lib for rendering progress bars in terminal applications.
+
+## Features
+
+- **Multiple Bars**: Multiple progress bars are supported
+- **Dynamic Total**: Set total while bar is running
+- **Dynamic Add/Remove**: Dynamically add or remove bars
+- **Cancellation**: Cancel whole rendering process
+- **Predefined Decorators**: Elapsed time, [ewma](https://github.com/VividCortex/ewma) based ETA, Percentage, Bytes counter
+- **Decorator's width sync**: Synchronized decorator's width among multiple bars
+
+## Usage
+
+#### [Rendering single bar](_examples/singleBar/main.go)
+
+```go
+package main
+
+import (
+    "math/rand"
+    "time"
+
+    "github.com/vbauerster/mpb/v6"
+    "github.com/vbauerster/mpb/v6/decor"
+)
+
+func main() {
+    // initialize progress container, with custom width
+    p := mpb.New(mpb.WithWidth(64))
+
+    total := 100
+    name := "Single Bar:"
+    // adding a single bar, which will inherit container's width
+    bar := p.Add(int64(total),
+        // progress bar filler with customized style
+        mpb.NewBarFiller("╢▌▌░╟"),
+        mpb.PrependDecorators(
+            // display our name with one space on the right
+            decor.Name(name, decor.WC{W: len(name) + 1, C: decor.DidentRight}),
+            // replace ETA decorator with "done" message, OnComplete event
+            decor.OnComplete(
+                decor.AverageETA(decor.ET_STYLE_GO, decor.WC{W: 4}), "done",
+            ),
+        ),
+        mpb.AppendDecorators(decor.Percentage()),
+    )
+    // simulating some work
+    max := 100 * time.Millisecond
+    for i := 0; i < total; i++ {
+        time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
+        bar.Increment()
+    }
+    // wait for our bar to complete and flush
+    p.Wait()
+}
+```
+
+#### [Rendering multiple bars](_examples/multiBars/main.go)
+
+```go
+    var wg sync.WaitGroup
+    // pass &wg (optional), so p will wait for it eventually
+    p := mpb.New(mpb.WithWaitGroup(&wg))
+    total, numBars := 100, 3
+    wg.Add(numBars)
+
+    for i := 0; i < numBars; i++ {
+        name := fmt.Sprintf("Bar#%d:", i)
+        bar := p.AddBar(int64(total),
+            mpb.PrependDecorators(
+                // simple name decorator
+                decor.Name(name),
+                // decor.DSyncWidth bit enables column width synchronization
+                decor.Percentage(decor.WCSyncSpace),
+            ),
+            mpb.AppendDecorators(
+                // replace ETA decorator with "done" message, OnComplete event
+                decor.OnComplete(
+                    // ETA decorator with ewma age of 60
+                    decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
+                ),
+            ),
+        )
+        // simulating some work
+        go func() {
+            defer wg.Done()
+            rng := rand.New(rand.NewSource(time.Now().UnixNano()))
+            max := 100 * time.Millisecond
+            for i := 0; i < total; i++ {
+                // start variable is solely for EWMA calculation
+                // EWMA's unit of measure is an iteration's duration
+                start := time.Now()
+                time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
+                bar.Increment()
+                // we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
+                bar.DecoratorEwmaUpdate(time.Since(start))
+            }
+        }()
+    }
+    // Waiting for passed &wg and for all bars to complete and flush
+    p.Wait()
+```
+
+#### [Dynamic total](_examples/dynTotal/main.go)
+
+![dynamic total](_svg/godEMrCZmJkHYH1X9dN4Nm0U7.svg)
+
+#### [Complex example](_examples/complex/main.go)
+
+![complex](_svg/wHzf1M7sd7B3zVa2scBMnjqRf.svg)
+
+#### [Bytes counters](_examples/io/main.go)
+
+![byte counters](_svg/hIpTa3A5rQz65ssiVuRJu87X6.svg)
diff --git a/vendor/github.com/vbauerster/mpb/v6/UNLICENSE b/vendor/github.com/vbauerster/mpb/v6/UNLICENSE
new file mode 100644
index 000000000..68a49daad
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/UNLICENSE
@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>
diff --git a/vendor/github.com/vbauerster/mpb/v6/bar.go b/vendor/github.com/vbauerster/mpb/v6/bar.go
new file mode 100644
index 000000000..f18ef967f
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/bar.go
@@ -0,0 +1,492 @@
+package mpb
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"log"
+	"runtime/debug"
+	"strings"
+	"time"
+
+	"github.com/acarl005/stripansi"
+	"github.com/mattn/go-runewidth"
+	"github.com/vbauerster/mpb/v6/decor"
+)
+
+// Bar represents a progress bar.
+type Bar struct {
+	priority int // used by heap
+	index    int // used by heap
+
+	extendedLines     int
+	toShutdown        bool
+	toDrop            bool
+	noPop             bool
+	hasEwmaDecorators bool
+	operateState      chan func(*bState)
+	frameCh           chan io.Reader
+	syncTableCh       chan [][]chan int
+	completed         chan bool
+
+	// cancel is called either by user or on complete event
+	cancel func()
+	// done is closed after cacheState is assigned
+	done chan struct{}
+	// cacheState is populated, right after close(shutdown)
+	cacheState *bState
+
+	container      *Progress
+	dlogger        *log.Logger
+	recoveredPanic interface{}
+}
+
+type extenderFunc func(in io.Reader, reqWidth int, st decor.Statistics) (out io.Reader, lines int)
+
+// bState is actual bar state. It gets passed to *Bar.serve(...) monitor
+// goroutine.
+type bState struct {
+	id                int
+	priority          int
+	reqWidth          int
+	total             int64
+	current           int64
+	refill            int64
+	lastN             int64
+	iterated          bool
+	trimSpace         bool
+	completed         bool
+	completeFlushed   bool
+	triggerComplete   bool
+	dropOnComplete    bool
+	noPop             bool
+	aDecorators       []decor.Decorator
+	pDecorators       []decor.Decorator
+	averageDecorators []decor.AverageDecorator
+	ewmaDecorators    []decor.EwmaDecorator
+	shutdownListeners []decor.ShutdownListener
+	bufP, bufB, bufA  *bytes.Buffer
+	filler            BarFiller
+	middleware        func(BarFiller) BarFiller
+	extender          extenderFunc
+
+	// runningBar is a key for *pState.parkedBars
+	runningBar *Bar
+
+	debugOut io.Writer
+}
+
+func newBar(container *Progress, bs *bState) *Bar {
+	logPrefix := fmt.Sprintf("%sbar#%02d ", container.dlogger.Prefix(), bs.id)
+	ctx, cancel := context.WithCancel(container.ctx)
+
+	bar := &Bar{
+		container:    container,
+		priority:     bs.priority,
+		toDrop:       bs.dropOnComplete,
+		noPop:        bs.noPop,
+		operateState: make(chan func(*bState)),
+		frameCh:      make(chan io.Reader, 1),
+		syncTableCh:  make(chan [][]chan int, 1),
+		completed:    make(chan bool, 1),
+		done:         make(chan struct{}),
+		cancel:       cancel,
+		dlogger:      log.New(bs.debugOut, logPrefix, log.Lshortfile),
+	}
+
+	go bar.serve(ctx, bs)
+	return bar
+}
+
+// ProxyReader wraps r with metrics required for progress tracking.
+// Panics if r is nil.
+func (b *Bar) ProxyReader(r io.Reader) io.ReadCloser {
+	if r == nil {
+		panic("expected non nil io.Reader")
+	}
+	return newProxyReader(r, b)
+}
+
+// ID returs id of the bar.
+func (b *Bar) ID() int {
+	result := make(chan int)
+	select {
+	case b.operateState <- func(s *bState) { result <- s.id }:
+		return <-result
+	case <-b.done:
+		return b.cacheState.id
+	}
+}
+
+// Current returns bar's current number, in other words sum of all increments.
+func (b *Bar) Current() int64 {
+	result := make(chan int64)
+	select {
+	case b.operateState <- func(s *bState) { result <- s.current }:
+		return <-result
+	case <-b.done:
+		return b.cacheState.current
+	}
+}
+
+// SetRefill sets refill flag with specified amount.
+// The underlying BarFiller will change its visual representation, to
+// indicate refill event. Refill event may be referred to some retry
+// operation for example.
+func (b *Bar) SetRefill(amount int64) {
+	select {
+	case b.operateState <- func(s *bState) {
+		s.refill = amount
+	}:
+	case <-b.done:
+	}
+}
+
+// TraverseDecorators traverses all available decorators and calls cb func on each.
+func (b *Bar) TraverseDecorators(cb func(decor.Decorator)) {
+	select {
+	case b.operateState <- func(s *bState) {
+		for _, decorators := range [...][]decor.Decorator{
+			s.pDecorators,
+			s.aDecorators,
+		} {
+			for _, d := range decorators {
+				cb(extractBaseDecorator(d))
+			}
+		}
+	}:
+	case <-b.done:
+	}
+}
+
+// SetTotal sets total dynamically.
+// If total is less than or equal to zero it takes progress' current value.
+func (b *Bar) SetTotal(total int64, triggerComplete bool) {
+	select {
+	case b.operateState <- func(s *bState) {
+		s.triggerComplete = triggerComplete
+		if total <= 0 {
+			s.total = s.current
+		} else {
+			s.total = total
+		}
+		if s.triggerComplete && !s.completed {
+			s.current = s.total
+			s.completed = true
+			go b.refreshTillShutdown()
+		}
+	}:
+	case <-b.done:
+	}
+}
+
+// SetCurrent sets progress' current to an arbitrary value.
+// Setting a negative value will cause a panic.
+func (b *Bar) SetCurrent(current int64) {
+	select {
+	case b.operateState <- func(s *bState) {
+		s.iterated = true
+		s.lastN = current - s.current
+		s.current = current
+		if s.triggerComplete && s.current >= s.total {
+			s.current = s.total
+			s.completed = true
+			go b.refreshTillShutdown()
+		}
+	}:
+	case <-b.done:
+	}
+}
+
+// Increment is a shorthand for b.IncrInt64(1).
+func (b *Bar) Increment() {
+	b.IncrInt64(1)
+}
+
+// IncrBy is a shorthand for b.IncrInt64(int64(n)).
+func (b *Bar) IncrBy(n int) {
+	b.IncrInt64(int64(n))
+}
+
+// IncrInt64 increments progress by amount of n.
+func (b *Bar) IncrInt64(n int64) {
+	select {
+	case b.operateState <- func(s *bState) {
+		s.iterated = true
+		s.lastN = n
+		s.current += n
+		if s.triggerComplete && s.current >= s.total {
+			s.current = s.total
+			s.completed = true
+			go b.refreshTillShutdown()
+		}
+	}:
+	case <-b.done:
+	}
+}
+
+// DecoratorEwmaUpdate updates all EWMA based decorators. Should be
+// called on each iteration, because EWMA's unit of measure is an
+// iteration's duration. Panics if called before *Bar.Incr... family
+// methods.
+func (b *Bar) DecoratorEwmaUpdate(dur time.Duration) {
+	select {
+	case b.operateState <- func(s *bState) {
+		ewmaIterationUpdate(false, s, dur)
+	}:
+	case <-b.done:
+		ewmaIterationUpdate(true, b.cacheState, dur)
+	}
+}
+
+// DecoratorAverageAdjust adjusts all average based decorators. Call
+// if you need to adjust start time of all average based decorators
+// or after progress resume.
+func (b *Bar) DecoratorAverageAdjust(start time.Time) {
+	select {
+	case b.operateState <- func(s *bState) {
+		for _, d := range s.averageDecorators {
+			d.AverageAdjust(start)
+		}
+	}:
+	case <-b.done:
+	}
+}
+
+// SetPriority changes bar's order among multiple bars. Zero is highest
+// priority, i.e. bar will be on top. If you don't need to set priority
+// dynamically, better use BarPriority option.
+func (b *Bar) SetPriority(priority int) {
+	select {
+	case <-b.done:
+	default:
+		b.container.setBarPriority(b, priority)
+	}
+}
+
+// Abort interrupts bar's running goroutine. Call this, if you'd like
+// to stop/remove bar before completion event. It has no effect after
+// completion event. If drop is true bar will be removed as well.
+func (b *Bar) Abort(drop bool) {
+	select {
+	case <-b.done:
+	default:
+		if drop {
+			b.container.dropBar(b)
+		}
+		b.cancel()
+	}
+}
+
+// Completed reports whether the bar is in completed state.
+func (b *Bar) Completed() bool {
+	select {
+	case b.operateState <- func(s *bState) { b.completed <- s.completed }:
+		return <-b.completed
+	case <-b.done:
+		return true
+	}
+}
+
+func (b *Bar) serve(ctx context.Context, s *bState) {
+	defer b.container.bwg.Done()
+	for {
+		select {
+		case op := <-b.operateState:
+			op(s)
+		case <-ctx.Done():
+			b.cacheState = s
+			close(b.done)
+			// Notifying decorators about shutdown event
+			for _, sl := range s.shutdownListeners {
+				sl.Shutdown()
+			}
+			return
+		}
+	}
+}
+
+func (b *Bar) render(tw int) {
+	select {
+	case b.operateState <- func(s *bState) {
+		stat := newStatistics(tw, s)
+		defer func() {
+			// recovering if user defined decorator panics for example
+			if p := recover(); p != nil {
+				if b.recoveredPanic == nil {
+					s.extender = makePanicExtender(p)
+					b.toShutdown = !b.toShutdown
+					b.recoveredPanic = p
+				}
+				frame, lines := s.extender(nil, s.reqWidth, stat)
+				b.extendedLines = lines
+				b.frameCh <- frame
+				b.dlogger.Println(p)
+			}
+			s.completeFlushed = s.completed
+		}()
+		frame, lines := s.extender(s.draw(stat), s.reqWidth, stat)
+		b.extendedLines = lines
+		b.toShutdown = s.completed && !s.completeFlushed
+		b.frameCh <- frame
+	}:
+	case <-b.done:
+		s := b.cacheState
+		stat := newStatistics(tw, s)
+		var r io.Reader
+		if b.recoveredPanic == nil {
+			r = s.draw(stat)
+		}
+		frame, lines := s.extender(r, s.reqWidth, stat)
+		b.extendedLines = lines
+		b.frameCh <- frame
+	}
+}
+
+func (b *Bar) subscribeDecorators() {
+	var averageDecorators []decor.AverageDecorator
+	var ewmaDecorators []decor.EwmaDecorator
+	var shutdownListeners []decor.ShutdownListener
+	b.TraverseDecorators(func(d decor.Decorator) {
+		if d, ok := d.(decor.AverageDecorator); ok {
+			averageDecorators = append(averageDecorators, d)
+		}
+		if d, ok := d.(decor.EwmaDecorator); ok {
+			ewmaDecorators = append(ewmaDecorators, d)
+		}
+		if d, ok := d.(decor.ShutdownListener); ok {
+			shutdownListeners = append(shutdownListeners, d)
+		}
+	})
+	select {
+	case b.operateState <- func(s *bState) {
+		s.averageDecorators = averageDecorators
+		s.ewmaDecorators = ewmaDecorators
+		s.shutdownListeners = shutdownListeners
+	}:
+		b.hasEwmaDecorators = len(ewmaDecorators) != 0
+	case <-b.done:
+	}
+}
+
+func (b *Bar) refreshTillShutdown() {
+	for {
+		select {
+		case b.container.refreshCh <- time.Now():
+		case <-b.done:
+			return
+		}
+	}
+}
+
+func (b *Bar) wSyncTable() [][]chan int {
+	select {
+	case b.operateState <- func(s *bState) { b.syncTableCh <- s.wSyncTable() }:
+		return <-b.syncTableCh
+	case <-b.done:
+		return b.cacheState.wSyncTable()
+	}
+}
+
+func (s *bState) draw(stat decor.Statistics) io.Reader {
+	if !s.trimSpace {
+		stat.AvailableWidth -= 2
+		s.bufB.WriteByte(' ')
+		defer s.bufB.WriteByte(' ')
+	}
+
+	nlr := strings.NewReader("\n")
+	tw := stat.AvailableWidth
+	for _, d := range s.pDecorators {
+		str := d.Decor(stat)
+		stat.AvailableWidth -= runewidth.StringWidth(stripansi.Strip(str))
+		s.bufP.WriteString(str)
+	}
+	if stat.AvailableWidth <= 0 {
+		trunc := strings.NewReader(runewidth.Truncate(stripansi.Strip(s.bufP.String()), tw, "…"))
+		s.bufP.Reset()
+		return io.MultiReader(trunc, s.bufB, nlr)
+	}
+
+	tw = stat.AvailableWidth
+	for _, d := range s.aDecorators {
+		str := d.Decor(stat)
+		stat.AvailableWidth -= runewidth.StringWidth(stripansi.Strip(str))
+		s.bufA.WriteString(str)
+	}
+	if stat.AvailableWidth <= 0 {
+		trunc := strings.NewReader(runewidth.Truncate(stripansi.Strip(s.bufA.String()), tw, "…"))
+		s.bufA.Reset()
+		return io.MultiReader(s.bufP, s.bufB, trunc, nlr)
+	}
+
+	s.filler.Fill(s.bufB, s.reqWidth, stat)
+
+	return io.MultiReader(s.bufP, s.bufB, s.bufA, nlr)
+}
+
+func (s *bState) wSyncTable() [][]chan int {
+	columns := make([]chan int, 0, len(s.pDecorators)+len(s.aDecorators))
+	var pCount int
+	for _, d := range s.pDecorators {
+		if ch, ok := d.Sync(); ok {
+			columns = append(columns, ch)
+			pCount++
+		}
+	}
+	var aCount int
+	for _, d := range s.aDecorators {
+		if ch, ok := d.Sync(); ok {
+			columns = append(columns, ch)
+			aCount++
+		}
+	}
+	table := make([][]chan int, 2)
+	table[0] = columns[0:pCount]
+	table[1] = columns[pCount : pCount+aCount : pCount+aCount]
+	return table
+}
+
+func newStatistics(tw int, s *bState) decor.Statistics {
+	return decor.Statistics{
+		ID:             s.id,
+		AvailableWidth: tw,
+		Total:          s.total,
+		Current:        s.current,
+		Refill:         s.refill,
+		Completed:      s.completeFlushed,
+	}
+}
+
+func extractBaseDecorator(d decor.Decorator) decor.Decorator {
+	if d, ok := d.(decor.Wrapper); ok {
+		return extractBaseDecorator(d.Base())
+	}
+	return d
+}
+
+func ewmaIterationUpdate(done bool, s *bState, dur time.Duration) {
+	if !done && !s.iterated {
+		panic("increment required before ewma iteration update")
+	} else {
+		s.iterated = false
+	}
+	for _, d := range s.ewmaDecorators {
+		d.EwmaUpdate(s.lastN, dur)
+	}
+}
+
+func makePanicExtender(p interface{}) extenderFunc {
+	pstr := fmt.Sprint(p)
+	stack := debug.Stack()
+	stackLines := bytes.Count(stack, []byte("\n"))
+	return func(_ io.Reader, _ int, st decor.Statistics) (io.Reader, int) {
+		mr := io.MultiReader(
+			strings.NewReader(runewidth.Truncate(pstr, st.AvailableWidth, "…")),
+			strings.NewReader(fmt.Sprintf("\n%#v\n", st)),
+			bytes.NewReader(stack),
+		)
+		return mr, stackLines + 1
+	}
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/bar_filler.go b/vendor/github.com/vbauerster/mpb/v6/bar_filler.go
new file mode 100644
index 000000000..c8cedaa4a
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/bar_filler.go
@@ -0,0 +1,31 @@
+package mpb
+
+import (
+	"io"
+
+	"github.com/vbauerster/mpb/v6/decor"
+)
+
+// BarFiller interface.
+// Bar (without decorators) renders itself by calling BarFiller's Fill method.
+//
+//	reqWidth is requested width, set by `func WithWidth(int) ContainerOption`.
+//	If not set, it defaults to terminal width.
+//
+// Default implementations can be obtained via:
+//
+//	func NewBarFiller(style string) BarFiller
+//	func NewBarFillerRev(style string) BarFiller
+//	func NewBarFillerPick(style string, rev bool) BarFiller
+//	func NewSpinnerFiller(style []string, alignment SpinnerAlignment) BarFiller
+//
+type BarFiller interface {
+	Fill(w io.Writer, reqWidth int, stat decor.Statistics)
+}
+
+// BarFillerFunc is function type adapter to convert function into BarFiller.
+type BarFillerFunc func(w io.Writer, reqWidth int, stat decor.Statistics)
+
+func (f BarFillerFunc) Fill(w io.Writer, reqWidth int, stat decor.Statistics) {
+	f(w, reqWidth, stat)
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/bar_filler_bar.go b/vendor/github.com/vbauerster/mpb/v6/bar_filler_bar.go
new file mode 100644
index 000000000..50494485e
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/bar_filler_bar.go
@@ -0,0 +1,191 @@
+package mpb
+
+import (
+	"bytes"
+	"io"
+	"unicode/utf8"
+
+	"github.com/mattn/go-runewidth"
+	"github.com/rivo/uniseg"
+	"github.com/vbauerster/mpb/v6/decor"
+	"github.com/vbauerster/mpb/v6/internal"
+)
+
+const (
+	rLeft = iota
+	rFill
+	rTip
+	rSpace
+	rRight
+	rRevTip
+	rRefill
+)
+
+// BarDefaultStyle is a style for rendering a progress bar.
+// It consist of 7 ordered runes:
+//
+//	'1st rune' stands for left boundary rune
+//
+//	'2nd rune' stands for fill rune
+//
+//	'3rd rune' stands for tip rune
+//
+//	'4th rune' stands for space rune
+//
+//	'5th rune' stands for right boundary rune
+//
+//	'6th rune' stands for reverse tip rune
+//
+//	'7th rune' stands for refill rune
+//
+const BarDefaultStyle string = "[=>-]<+"
+
+type barFiller struct {
+	format  [][]byte
+	rwidth  []int
+	tip     []byte
+	refill  int64
+	reverse bool
+	flush   func(io.Writer, *space, [][]byte)
+}
+
+type space struct {
+	space  []byte
+	rwidth int
+	count  int
+}
+
+// NewBarFiller returns a BarFiller implementation which renders a
+// progress bar in regular direction. If style is empty string,
+// BarDefaultStyle is applied. To be used with `*Progress.Add(...)
+// *Bar` method.
+func NewBarFiller(style string) BarFiller {
+	return newBarFiller(style, false)
+}
+
+// NewBarFillerRev returns a BarFiller implementation which renders a
+// progress bar in reverse direction. If style is empty string,
+// BarDefaultStyle is applied. To be used with `*Progress.Add(...)
+// *Bar` method.
+func NewBarFillerRev(style string) BarFiller {
+	return newBarFiller(style, true)
+}
+
+// NewBarFillerPick pick between regular and reverse BarFiller implementation
+// based on rev param. To be used with `*Progress.Add(...) *Bar` method.
+func NewBarFillerPick(style string, rev bool) BarFiller {
+	return newBarFiller(style, rev)
+}
+
+func newBarFiller(style string, rev bool) BarFiller {
+	bf := &barFiller{
+		format:  make([][]byte, len(BarDefaultStyle)),
+		rwidth:  make([]int, len(BarDefaultStyle)),
+		reverse: rev,
+	}
+	bf.parse(BarDefaultStyle)
+	if style != "" && style != BarDefaultStyle {
+		bf.parse(style)
+	}
+	return bf
+}
+
+func (s *barFiller) parse(style string) {
+	if !utf8.ValidString(style) {
+		panic("invalid bar style")
+	}
+	srcFormat := make([][]byte, 0, len(BarDefaultStyle))
+	srcRwidth := make([]int, 0, len(BarDefaultStyle))
+	gr := uniseg.NewGraphemes(style)
+	for gr.Next() {
+		srcFormat = append(srcFormat, gr.Bytes())
+		srcRwidth = append(srcRwidth, runewidth.StringWidth(gr.Str()))
+	}
+	copy(s.format, srcFormat)
+	copy(s.rwidth, srcRwidth)
+	if s.reverse {
+		s.tip = s.format[rRevTip]
+		s.flush = reverseFlush
+	} else {
+		s.tip = s.format[rTip]
+		s.flush = regularFlush
+	}
+}
+
+func (s *barFiller) Fill(w io.Writer, reqWidth int, stat decor.Statistics) {
+	width := internal.CheckRequestedWidth(reqWidth, stat.AvailableWidth)
+	brackets := s.rwidth[rLeft] + s.rwidth[rRight]
+	if width < brackets {
+		return
+	}
+	// don't count brackets as progress
+	width -= brackets
+
+	w.Write(s.format[rLeft])
+	defer w.Write(s.format[rRight])
+
+	cwidth := int(internal.PercentageRound(stat.Total, stat.Current, width))
+	space := &space{
+		space:  s.format[rSpace],
+		rwidth: s.rwidth[rSpace],
+		count:  width - cwidth,
+	}
+
+	index, refill := 0, 0
+	bb := make([][]byte, cwidth)
+
+	if cwidth > 0 && cwidth != width {
+		bb[index] = s.tip
+		cwidth -= s.rwidth[rTip]
+		index++
+	}
+
+	if stat.Refill > 0 {
+		refill = int(internal.PercentageRound(stat.Total, int64(stat.Refill), width))
+		if refill > cwidth {
+			refill = cwidth
+		}
+		cwidth -= refill
+	}
+
+	for cwidth > 0 {
+		bb[index] = s.format[rFill]
+		cwidth -= s.rwidth[rFill]
+		index++
+	}
+
+	for refill > 0 {
+		bb[index] = s.format[rRefill]
+		refill -= s.rwidth[rRefill]
+		index++
+	}
+
+	if cwidth+refill < 0 || space.rwidth > 1 {
+		buf := new(bytes.Buffer)
+		s.flush(buf, space, bb[:index])
+		io.WriteString(w, runewidth.Truncate(buf.String(), width, "…"))
+		return
+	}
+
+	s.flush(w, space, bb)
+}
+
+func regularFlush(w io.Writer, space *space, bb [][]byte) {
+	for i := len(bb) - 1; i >= 0; i-- {
+		w.Write(bb[i])
+	}
+	for space.count > 0 {
+		w.Write(space.space)
+		space.count -= space.rwidth
+	}
+}
+
+func reverseFlush(w io.Writer, space *space, bb [][]byte) {
+	for space.count > 0 {
+		w.Write(space.space)
+		space.count -= space.rwidth
+	}
+	for i := 0; i < len(bb); i++ {
+		w.Write(bb[i])
+	}
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/bar_filler_spinner.go b/vendor/github.com/vbauerster/mpb/v6/bar_filler_spinner.go
new file mode 100644
index 000000000..0817b19ec
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/bar_filler_spinner.go
@@ -0,0 +1,65 @@
+package mpb
+
+import (
+	"io"
+	"strings"
+
+	"github.com/mattn/go-runewidth"
+	"github.com/vbauerster/mpb/v6/decor"
+	"github.com/vbauerster/mpb/v6/internal"
+)
+
+// SpinnerAlignment enum.
+type SpinnerAlignment int
+
+// SpinnerAlignment kinds.
+const (
+	SpinnerOnLeft SpinnerAlignment = iota
+	SpinnerOnMiddle
+	SpinnerOnRight
+)
+
+// SpinnerDefaultStyle is a style for rendering a spinner.
+var SpinnerDefaultStyle = []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
+
+type spinnerFiller struct {
+	frames    []string
+	count     uint
+	alignment SpinnerAlignment
+}
+
+// NewSpinnerFiller returns a BarFiller implementation which renders
+// a spinner. If style is nil or zero length, SpinnerDefaultStyle is
+// applied. To be used with `*Progress.Add(...) *Bar` method.
+func NewSpinnerFiller(style []string, alignment SpinnerAlignment) BarFiller {
+	if len(style) == 0 {
+		style = SpinnerDefaultStyle
+	}
+	filler := &spinnerFiller{
+		frames:    style,
+		alignment: alignment,
+	}
+	return filler
+}
+
+func (s *spinnerFiller) Fill(w io.Writer, reqWidth int, stat decor.Statistics) {
+	width := internal.CheckRequestedWidth(reqWidth, stat.AvailableWidth)
+
+	frame := s.frames[s.count%uint(len(s.frames))]
+	frameWidth := runewidth.StringWidth(frame)
+
+	if width < frameWidth {
+		return
+	}
+
+	switch rest := width - frameWidth; s.alignment {
+	case SpinnerOnLeft:
+		io.WriteString(w, frame+strings.Repeat(" ", rest))
+	case SpinnerOnMiddle:
+		str := strings.Repeat(" ", rest/2) + frame + strings.Repeat(" ", rest/2+rest%2)
+		io.WriteString(w, str)
+	case SpinnerOnRight:
+		io.WriteString(w, strings.Repeat(" ", rest)+frame)
+	}
+	s.count++
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/bar_option.go b/vendor/github.com/vbauerster/mpb/v6/bar_option.go
new file mode 100644
index 000000000..e359c110c
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/bar_option.go
@@ -0,0 +1,153 @@
+package mpb
+
+import (
+	"bytes"
+	"io"
+
+	"github.com/vbauerster/mpb/v6/decor"
+	"github.com/vbauerster/mpb/v6/internal"
+)
+
+// BarOption is a func option to alter default behavior of a bar.
+type BarOption func(*bState)
+
+func (s *bState) addDecorators(dest *[]decor.Decorator, decorators ...decor.Decorator) {
+	type mergeWrapper interface {
+		MergeUnwrap() []decor.Decorator
+	}
+	for _, decorator := range decorators {
+		if mw, ok := decorator.(mergeWrapper); ok {
+			*dest = append(*dest, mw.MergeUnwrap()...)
+		}
+		*dest = append(*dest, decorator)
+	}
+}
+
+// AppendDecorators let you inject decorators to the bar's right side.
+func AppendDecorators(decorators ...decor.Decorator) BarOption {
+	return func(s *bState) {
+		s.addDecorators(&s.aDecorators, decorators...)
+	}
+}
+
+// PrependDecorators let you inject decorators to the bar's left side.
+func PrependDecorators(decorators ...decor.Decorator) BarOption {
+	return func(s *bState) {
+		s.addDecorators(&s.pDecorators, decorators...)
+	}
+}
+
+// BarID sets bar id.
+func BarID(id int) BarOption {
+	return func(s *bState) {
+		s.id = id
+	}
+}
+
+// BarWidth sets bar width independent of the container.
+func BarWidth(width int) BarOption {
+	return func(s *bState) {
+		s.reqWidth = width
+	}
+}
+
+// BarQueueAfter queues this (being constructed) bar to relplace
+// runningBar after it has been completed.
+func BarQueueAfter(runningBar *Bar) BarOption {
+	if runningBar == nil {
+		return nil
+	}
+	return func(s *bState) {
+		s.runningBar = runningBar
+	}
+}
+
+// BarRemoveOnComplete removes both bar's filler and its decorators
+// on complete event.
+func BarRemoveOnComplete() BarOption {
+	return func(s *bState) {
+		s.dropOnComplete = true
+	}
+}
+
+// BarFillerClearOnComplete clears bar's filler on complete event.
+// It's shortcut for BarFillerOnComplete("").
+func BarFillerClearOnComplete() BarOption {
+	return BarFillerOnComplete("")
+}
+
+// BarFillerOnComplete replaces bar's filler with message, on complete event.
+func BarFillerOnComplete(message string) BarOption {
+	return BarFillerMiddleware(func(base BarFiller) BarFiller {
+		return BarFillerFunc(func(w io.Writer, reqWidth int, st decor.Statistics) {
+			if st.Completed {
+				io.WriteString(w, message)
+			} else {
+				base.Fill(w, reqWidth, st)
+			}
+		})
+	})
+}
+
+// BarFillerMiddleware provides a way to augment the underlying BarFiller.
+func BarFillerMiddleware(middle func(BarFiller) BarFiller) BarOption {
+	return func(s *bState) {
+		s.middleware = middle
+	}
+}
+
+// BarPriority sets bar's priority. Zero is highest priority, i.e. bar
+// will be on top. If `BarReplaceOnComplete` option is supplied, this
+// option is ignored.
+func BarPriority(priority int) BarOption {
+	return func(s *bState) {
+		s.priority = priority
+	}
+}
+
+// BarExtender provides a way to extend bar to the next new line.
+func BarExtender(filler BarFiller) BarOption {
+	if filler == nil {
+		return nil
+	}
+	return func(s *bState) {
+		s.extender = makeExtenderFunc(filler)
+	}
+}
+
+func makeExtenderFunc(filler BarFiller) extenderFunc {
+	buf := new(bytes.Buffer)
+	return func(r io.Reader, reqWidth int, st decor.Statistics) (io.Reader, int) {
+		filler.Fill(buf, reqWidth, st)
+		return io.MultiReader(r, buf), bytes.Count(buf.Bytes(), []byte("\n"))
+	}
+}
+
+// BarFillerTrim removes leading and trailing space around the underlying BarFiller.
+func BarFillerTrim() BarOption {
+	return func(s *bState) {
+		s.trimSpace = true
+	}
+}
+
+// BarNoPop disables bar pop out of container. Effective when
+// PopCompletedMode of container is enabled.
+func BarNoPop() BarOption {
+	return func(s *bState) {
+		s.noPop = true
+	}
+}
+
+// BarOptional will invoke provided option only when pick is true.
+func BarOptional(option BarOption, pick bool) BarOption {
+	return BarOptOn(option, internal.Predicate(pick))
+}
+
+// BarOptOn will invoke provided option only when higher order predicate
+// evaluates to true.
+func BarOptOn(option BarOption, predicate func() bool) BarOption {
+	if predicate() {
+		return option
+	}
+	return nil
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/container_option.go b/vendor/github.com/vbauerster/mpb/v6/container_option.go
new file mode 100644
index 000000000..b92c7578c
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/container_option.go
@@ -0,0 +1,112 @@
+package mpb
+
+import (
+	"io"
+	"io/ioutil"
+	"sync"
+	"time"
+
+	"github.com/vbauerster/mpb/v6/internal"
+)
+
+// ContainerOption is a func option to alter default behavior of a bar
+// container. Container term refers to a Progress struct which can
+// hold one or more Bars.
+type ContainerOption func(*pState)
+
+// WithWaitGroup provides means to have a single joint point. If
+// *sync.WaitGroup is provided, you can safely call just p.Wait()
+// without calling Wait() on provided *sync.WaitGroup. Makes sense
+// when there are more than one bar to render.
+func WithWaitGroup(wg *sync.WaitGroup) ContainerOption {
+	return func(s *pState) {
+		s.uwg = wg
+	}
+}
+
+// WithWidth sets container width. If not set it defaults to terminal
+// width. A bar added to the container will inherit its width, unless
+// overridden by `func BarWidth(int) BarOption`.
+func WithWidth(width int) ContainerOption {
+	return func(s *pState) {
+		s.reqWidth = width
+	}
+}
+
+// WithRefreshRate overrides default 120ms refresh rate.
+func WithRefreshRate(d time.Duration) ContainerOption {
+	return func(s *pState) {
+		s.rr = d
+	}
+}
+
+// WithManualRefresh disables internal auto refresh time.Ticker.
+// Refresh will occur upon receive value from provided ch.
+func WithManualRefresh(ch <-chan interface{}) ContainerOption {
+	return func(s *pState) {
+		s.externalRefresh = ch
+	}
+}
+
+// WithRenderDelay delays rendering. By default rendering starts as
+// soon as bar is added, with this option it's possible to delay
+// rendering process by keeping provided chan unclosed. In other words
+// rendering will start as soon as provided chan is closed.
+func WithRenderDelay(ch <-chan struct{}) ContainerOption {
+	return func(s *pState) {
+		s.renderDelay = ch
+	}
+}
+
+// WithShutdownNotifier provided chanel will be closed, after all bars
+// have been rendered.
+func WithShutdownNotifier(ch chan struct{}) ContainerOption {
+	return func(s *pState) {
+		s.shutdownNotifier = ch
+	}
+}
+
+// WithOutput overrides default os.Stdout output. Setting it to nil
+// will effectively disable auto refresh rate and discard any output,
+// useful if you want to disable progress bars with little overhead.
+func WithOutput(w io.Writer) ContainerOption {
+	return func(s *pState) {
+		if w == nil {
+			s.output = ioutil.Discard
+			s.outputDiscarded = true
+			return
+		}
+		s.output = w
+	}
+}
+
+// WithDebugOutput sets debug output.
+func WithDebugOutput(w io.Writer) ContainerOption {
+	if w == nil {
+		return nil
+	}
+	return func(s *pState) {
+		s.debugOut = w
+	}
+}
+
+// PopCompletedMode will pop and stop rendering completed bars.
+func PopCompletedMode() ContainerOption {
+	return func(s *pState) {
+		s.popCompleted = true
+	}
+}
+
+// ContainerOptional will invoke provided option only when pick is true.
+func ContainerOptional(option ContainerOption, pick bool) ContainerOption {
+	return ContainerOptOn(option, internal.Predicate(pick))
+}
+
+// ContainerOptOn will invoke provided option only when higher order
+// predicate evaluates to true.
+func ContainerOptOn(option ContainerOption, predicate func() bool) ContainerOption {
+	if predicate() {
+		return option
+	}
+	return nil
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/cwriter/doc.go b/vendor/github.com/vbauerster/mpb/v6/cwriter/doc.go
new file mode 100644
index 000000000..93c8f8268
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/cwriter/doc.go
@@ -0,0 +1,2 @@
+// Package cwriter is a console writer abstraction for the underlying OS.
+package cwriter
diff --git a/vendor/github.com/vbauerster/mpb/v6/cwriter/util_bsd.go b/vendor/github.com/vbauerster/mpb/v6/cwriter/util_bsd.go
new file mode 100644
index 000000000..4e3564ece
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/cwriter/util_bsd.go
@@ -0,0 +1,7 @@
+// +build darwin dragonfly freebsd netbsd openbsd
+
+package cwriter
+
+import "golang.org/x/sys/unix"
+
+const ioctlReadTermios = unix.TIOCGETA
diff --git a/vendor/github.com/vbauerster/mpb/v6/cwriter/util_linux.go b/vendor/github.com/vbauerster/mpb/v6/cwriter/util_linux.go
new file mode 100644
index 000000000..253f12dd2
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/cwriter/util_linux.go
@@ -0,0 +1,7 @@
+// +build aix linux
+
+package cwriter
+
+import "golang.org/x/sys/unix"
+
+const ioctlReadTermios = unix.TCGETS
diff --git a/vendor/github.com/vbauerster/mpb/v6/cwriter/util_solaris.go b/vendor/github.com/vbauerster/mpb/v6/cwriter/util_solaris.go
new file mode 100644
index 000000000..4b29ff5c0
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/cwriter/util_solaris.go
@@ -0,0 +1,7 @@
+// +build solaris
+
+package cwriter
+
+import "golang.org/x/sys/unix"
+
+const ioctlReadTermios = unix.TCGETA
diff --git a/vendor/github.com/vbauerster/mpb/v6/cwriter/writer.go b/vendor/github.com/vbauerster/mpb/v6/cwriter/writer.go
new file mode 100644
index 000000000..1ade54761
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/cwriter/writer.go
@@ -0,0 +1,84 @@
+package cwriter
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"os"
+	"strconv"
+)
+
+// ErrNotTTY not a TeleTYpewriter error.
+var ErrNotTTY = errors.New("not a terminal")
+
+// http://ascii-table.com/ansi-escape-sequences.php
+const (
+	escOpen  = "\x1b["
+	cuuAndEd = "A\x1b[J"
+)
+
+// Writer is a buffered the writer that updates the terminal. The
+// contents of writer will be flushed when Flush is called.
+type Writer struct {
+	out        io.Writer
+	buf        bytes.Buffer
+	lineCount  int
+	fd         int
+	isTerminal bool
+}
+
+// New returns a new Writer with defaults.
+func New(out io.Writer) *Writer {
+	w := &Writer{out: out}
+	if f, ok := out.(*os.File); ok {
+		w.fd = int(f.Fd())
+		w.isTerminal = IsTerminal(w.fd)
+	}
+	return w
+}
+
+// Flush flushes the underlying buffer.
+func (w *Writer) Flush(lineCount int) (err error) {
+	// some terminals interpret 'cursor up 0' as 'cursor up 1'
+	if w.lineCount > 0 {
+		err = w.clearLines()
+		if err != nil {
+			return
+		}
+	}
+	w.lineCount = lineCount
+	_, err = w.buf.WriteTo(w.out)
+	return
+}
+
+// Write appends the contents of p to the underlying buffer.
+func (w *Writer) Write(p []byte) (n int, err error) {
+	return w.buf.Write(p)
+}
+
+// WriteString writes string to the underlying buffer.
+func (w *Writer) WriteString(s string) (n int, err error) {
+	return w.buf.WriteString(s)
+}
+
+// ReadFrom reads from the provided io.Reader and writes to the
+// underlying buffer.
+func (w *Writer) ReadFrom(r io.Reader) (n int64, err error) {
+	return w.buf.ReadFrom(r)
+}
+
+// GetWidth returns width of underlying terminal.
+func (w *Writer) GetWidth() (int, error) {
+	if !w.isTerminal {
+		return -1, ErrNotTTY
+	}
+	tw, _, err := GetSize(w.fd)
+	return tw, err
+}
+
+func (w *Writer) ansiCuuAndEd() (err error) {
+	buf := make([]byte, 8)
+	buf = strconv.AppendInt(buf[:copy(buf, escOpen)], int64(w.lineCount), 10)
+	_, err = w.out.Write(append(buf, cuuAndEd...))
+	return
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/cwriter/writer_posix.go b/vendor/github.com/vbauerster/mpb/v6/cwriter/writer_posix.go
new file mode 100644
index 000000000..f54a5d06b
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/cwriter/writer_posix.go
@@ -0,0 +1,26 @@
+// +build !windows
+
+package cwriter
+
+import (
+	"golang.org/x/sys/unix"
+)
+
+func (w *Writer) clearLines() error {
+	return w.ansiCuuAndEd()
+}
+
+// GetSize returns the dimensions of the given terminal.
+func GetSize(fd int) (width, height int, err error) {
+	ws, err := unix.IoctlGetWinsize(fd, unix.TIOCGWINSZ)
+	if err != nil {
+		return -1, -1, err
+	}
+	return int(ws.Col), int(ws.Row), nil
+}
+
+// IsTerminal returns whether the given file descriptor is a terminal.
+func IsTerminal(fd int) bool {
+	_, err := unix.IoctlGetTermios(fd, ioctlReadTermios)
+	return err == nil
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/cwriter/writer_windows.go b/vendor/github.com/vbauerster/mpb/v6/cwriter/writer_windows.go
new file mode 100644
index 000000000..1a69c81ac
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/cwriter/writer_windows.go
@@ -0,0 +1,73 @@
+// +build windows
+
+package cwriter
+
+import (
+	"unsafe"
+
+	"golang.org/x/sys/windows"
+)
+
+var kernel32 = windows.NewLazySystemDLL("kernel32.dll")
+
+var (
+	procSetConsoleCursorPosition   = kernel32.NewProc("SetConsoleCursorPosition")
+	procFillConsoleOutputCharacter = kernel32.NewProc("FillConsoleOutputCharacterW")
+)
+
+func (w *Writer) clearLines() error {
+	if !w.isTerminal {
+		// hope it's cygwin or similar
+		return w.ansiCuuAndEd()
+	}
+
+	var info windows.ConsoleScreenBufferInfo
+	if err := windows.GetConsoleScreenBufferInfo(windows.Handle(w.fd), &info); err != nil {
+		return err
+	}
+
+	info.CursorPosition.Y -= int16(w.lineCount)
+	if info.CursorPosition.Y < 0 {
+		info.CursorPosition.Y = 0
+	}
+	_, _, _ = procSetConsoleCursorPosition.Call(
+		uintptr(w.fd),
+		uintptr(uint32(uint16(info.CursorPosition.Y))<<16|uint32(uint16(info.CursorPosition.X))),
+	)
+
+	// clear the lines
+	cursor := &windows.Coord{
+		X: info.Window.Left,
+		Y: info.CursorPosition.Y,
+	}
+	count := uint32(info.Size.X) * uint32(w.lineCount)
+	_, _, _ = procFillConsoleOutputCharacter.Call(
+		uintptr(w.fd),
+		uintptr(' '),
+		uintptr(count),
+		*(*uintptr)(unsafe.Pointer(cursor)),
+		uintptr(unsafe.Pointer(new(uint32))),
+	)
+	return nil
+}
+
+// GetSize returns the visible dimensions of the given terminal.
+//
+// These dimensions don't include any scrollback buffer height.
+func GetSize(fd int) (width, height int, err error) {
+	var info windows.ConsoleScreenBufferInfo
+	if err := windows.GetConsoleScreenBufferInfo(windows.Handle(fd), &info); err != nil {
+		return 0, 0, err
+	}
+	// terminal.GetSize from crypto/ssh adds "+ 1" to both width and height:
+	// https://go.googlesource.com/crypto/+/refs/heads/release-branch.go1.14/ssh/terminal/util_windows.go#75
+	// but looks like this is a root cause of issue #66, so removing both "+ 1" have fixed it.
+	return int(info.Window.Right - info.Window.Left), int(info.Window.Bottom - info.Window.Top), nil
+}
+
+// IsTerminal returns whether the given file descriptor is a terminal.
+func IsTerminal(fd int) bool {
+	var st uint32
+	err := windows.GetConsoleMode(windows.Handle(fd), &st)
+	return err == nil
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/any.go b/vendor/github.com/vbauerster/mpb/v6/decor/any.go
new file mode 100644
index 000000000..39518f594
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/decor/any.go
@@ -0,0 +1,21 @@
+package decor
+
+// Any decorator displays text, that can be changed during decorator's
+// lifetime via provided DecorFunc.
+//
+//	`fn` DecorFunc callback
+//
+//	`wcc` optional WC config
+//
+func Any(fn DecorFunc, wcc ...WC) Decorator {
+	return &any{initWC(wcc...), fn}
+}
+
+type any struct {
+	WC
+	fn DecorFunc
+}
+
+func (d *any) Decor(s Statistics) string {
+	return d.FormatMsg(d.fn(s))
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/counters.go b/vendor/github.com/vbauerster/mpb/v6/decor/counters.go
new file mode 100644
index 000000000..4a5343d41
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/decor/counters.go
@@ -0,0 +1,243 @@
+package decor
+
+import (
+	"fmt"
+	"strings"
+)
+
+const (
+	_ = iota
+	UnitKiB
+	UnitKB
+)
+
+// CountersNoUnit is a wrapper around Counters with no unit param.
+func CountersNoUnit(pairFmt string, wcc ...WC) Decorator {
+	return Counters(0, pairFmt, wcc...)
+}
+
+// CountersKibiByte is a wrapper around Counters with predefined unit
+// UnitKiB (bytes/1024).
+func CountersKibiByte(pairFmt string, wcc ...WC) Decorator {
+	return Counters(UnitKiB, pairFmt, wcc...)
+}
+
+// CountersKiloByte is a wrapper around Counters with predefined unit
+// UnitKB (bytes/1000).
+func CountersKiloByte(pairFmt string, wcc ...WC) Decorator {
+	return Counters(UnitKB, pairFmt, wcc...)
+}
+
+// Counters decorator with dynamic unit measure adjustment.
+//
+//	`unit` one of [0|UnitKiB|UnitKB] zero for no unit
+//
+//	`pairFmt` printf compatible verbs for current and total pair
+//
+//	`wcc` optional WC config
+//
+// pairFmt example if unit=UnitKB:
+//
+//	pairFmt="%.1f / %.1f"   output: "1.0MB / 12.0MB"
+//	pairFmt="% .1f / % .1f" output: "1.0 MB / 12.0 MB"
+//	pairFmt="%d / %d"       output: "1MB / 12MB"
+//	pairFmt="% d / % d"     output: "1 MB / 12 MB"
+//
+func Counters(unit int, pairFmt string, wcc ...WC) Decorator {
+	producer := func(unit int, pairFmt string) DecorFunc {
+		if pairFmt == "" {
+			pairFmt = "%d / %d"
+		} else if strings.Count(pairFmt, "%") != 2 {
+			panic("expected pairFmt with exactly 2 verbs")
+		}
+		switch unit {
+		case UnitKiB:
+			return func(s Statistics) string {
+				return fmt.Sprintf(pairFmt, SizeB1024(s.Current), SizeB1024(s.Total))
+			}
+		case UnitKB:
+			return func(s Statistics) string {
+				return fmt.Sprintf(pairFmt, SizeB1000(s.Current), SizeB1000(s.Total))
+			}
+		default:
+			return func(s Statistics) string {
+				return fmt.Sprintf(pairFmt, s.Current, s.Total)
+			}
+		}
+	}
+	return Any(producer(unit, pairFmt), wcc...)
+}
+
+// TotalNoUnit is a wrapper around Total with no unit param.
+func TotalNoUnit(format string, wcc ...WC) Decorator {
+	return Total(0, format, wcc...)
+}
+
+// TotalKibiByte is a wrapper around Total with predefined unit
+// UnitKiB (bytes/1024).
+func TotalKibiByte(format string, wcc ...WC) Decorator {
+	return Total(UnitKiB, format, wcc...)
+}
+
+// TotalKiloByte is a wrapper around Total with predefined unit
+// UnitKB (bytes/1000).
+func TotalKiloByte(format string, wcc ...WC) Decorator {
+	return Total(UnitKB, format, wcc...)
+}
+
+// Total decorator with dynamic unit measure adjustment.
+//
+//	`unit` one of [0|UnitKiB|UnitKB] zero for no unit
+//
+//	`format` printf compatible verb for Total
+//
+//	`wcc` optional WC config
+//
+// format example if unit=UnitKiB:
+//
+//	format="%.1f"  output: "12.0MiB"
+//	format="% .1f" output: "12.0 MiB"
+//	format="%d"    output: "12MiB"
+//	format="% d"   output: "12 MiB"
+//
+func Total(unit int, format string, wcc ...WC) Decorator {
+	producer := func(unit int, format string) DecorFunc {
+		if format == "" {
+			format = "%d"
+		} else if strings.Count(format, "%") != 1 {
+			panic("expected format with exactly 1 verb")
+		}
+
+		switch unit {
+		case UnitKiB:
+			return func(s Statistics) string {
+				return fmt.Sprintf(format, SizeB1024(s.Total))
+			}
+		case UnitKB:
+			return func(s Statistics) string {
+				return fmt.Sprintf(format, SizeB1000(s.Total))
+			}
+		default:
+			return func(s Statistics) string {
+				return fmt.Sprintf(format, s.Total)
+			}
+		}
+	}
+	return Any(producer(unit, format), wcc...)
+}
+
+// CurrentNoUnit is a wrapper around Current with no unit param.
+func CurrentNoUnit(format string, wcc ...WC) Decorator {
+	return Current(0, format, wcc...)
+}
+
+// CurrentKibiByte is a wrapper around Current with predefined unit
+// UnitKiB (bytes/1024).
+func CurrentKibiByte(format string, wcc ...WC) Decorator {
+	return Current(UnitKiB, format, wcc...)
+}
+
+// CurrentKiloByte is a wrapper around Current with predefined unit
+// UnitKB (bytes/1000).
+func CurrentKiloByte(format string, wcc ...WC) Decorator {
+	return Current(UnitKB, format, wcc...)
+}
+
+// Current decorator with dynamic unit measure adjustment.
+//
+//	`unit` one of [0|UnitKiB|UnitKB] zero for no unit
+//
+//	`format` printf compatible verb for Current
+//
+//	`wcc` optional WC config
+//
+// format example if unit=UnitKiB:
+//
+//	format="%.1f"  output: "12.0MiB"
+//	format="% .1f" output: "12.0 MiB"
+//	format="%d"    output: "12MiB"
+//	format="% d"   output: "12 MiB"
+//
+func Current(unit int, format string, wcc ...WC) Decorator {
+	producer := func(unit int, format string) DecorFunc {
+		if format == "" {
+			format = "%d"
+		} else if strings.Count(format, "%") != 1 {
+			panic("expected format with exactly 1 verb")
+		}
+
+		switch unit {
+		case UnitKiB:
+			return func(s Statistics) string {
+				return fmt.Sprintf(format, SizeB1024(s.Current))
+			}
+		case UnitKB:
+			return func(s Statistics) string {
+				return fmt.Sprintf(format, SizeB1000(s.Current))
+			}
+		default:
+			return func(s Statistics) string {
+				return fmt.Sprintf(format, s.Current)
+			}
+		}
+	}
+	return Any(producer(unit, format), wcc...)
+}
+
+// InvertedCurrentNoUnit is a wrapper around InvertedCurrent with no unit param.
+func InvertedCurrentNoUnit(format string, wcc ...WC) Decorator {
+	return InvertedCurrent(0, format, wcc...)
+}
+
+// InvertedCurrentKibiByte is a wrapper around InvertedCurrent with predefined unit
+// UnitKiB (bytes/1024).
+func InvertedCurrentKibiByte(format string, wcc ...WC) Decorator {
+	return InvertedCurrent(UnitKiB, format, wcc...)
+}
+
+// InvertedCurrentKiloByte is a wrapper around InvertedCurrent with predefined unit
+// UnitKB (bytes/1000).
+func InvertedCurrentKiloByte(format string, wcc ...WC) Decorator {
+	return InvertedCurrent(UnitKB, format, wcc...)
+}
+
+// InvertedCurrent decorator with dynamic unit measure adjustment.
+//
+//	`unit` one of [0|UnitKiB|UnitKB] zero for no unit
+//
+//	`format` printf compatible verb for InvertedCurrent
+//
+//	`wcc` optional WC config
+//
+// format example if unit=UnitKiB:
+//
+//	format="%.1f"  output: "12.0MiB"
+//	format="% .1f" output: "12.0 MiB"
+//	format="%d"    output: "12MiB"
+//	format="% d"   output: "12 MiB"
+//
+func InvertedCurrent(unit int, format string, wcc ...WC) Decorator {
+	producer := func(unit int, format string) DecorFunc {
+		if format == "" {
+			format = "%d"
+		} else if strings.Count(format, "%") != 1 {
+			panic("expected format with exactly 1 verb")
+		}
+
+		switch unit {
+		case UnitKiB:
+			return func(s Statistics) string {
+				return fmt.Sprintf(format, SizeB1024(s.Total-s.Current))
+			}
+		case UnitKB:
+			return func(s Statistics) string {
+				return fmt.Sprintf(format, SizeB1000(s.Total-s.Current))
+			}
+		default:
+			return func(s Statistics) string {
+				return fmt.Sprintf(format, s.Total-s.Current)
+			}
+		}
+	}
+	return Any(producer(unit, format), wcc...)
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/decorator.go b/vendor/github.com/vbauerster/mpb/v6/decor/decorator.go
new file mode 100644
index 000000000..e81fae367
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/decor/decorator.go
@@ -0,0 +1,191 @@
+package decor
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/acarl005/stripansi"
+	"github.com/mattn/go-runewidth"
+)
+
+const (
+	// DidentRight bit specifies identation direction.
+	// |foo   |b     | With DidentRight
+	// |   foo|     b| Without DidentRight
+	DidentRight = 1 << iota
+
+	// DextraSpace bit adds extra space, makes sense with DSyncWidth only.
+	// When DidentRight bit set, the space will be added to the right,
+	// otherwise to the left.
+	DextraSpace
+
+	// DSyncWidth bit enables same column width synchronization.
+	// Effective with multiple bars only.
+	DSyncWidth
+
+	// DSyncWidthR is shortcut for DSyncWidth|DidentRight
+	DSyncWidthR = DSyncWidth | DidentRight
+
+	// DSyncSpace is shortcut for DSyncWidth|DextraSpace
+	DSyncSpace = DSyncWidth | DextraSpace
+
+	// DSyncSpaceR is shortcut for DSyncWidth|DextraSpace|DidentRight
+	DSyncSpaceR = DSyncWidth | DextraSpace | DidentRight
+)
+
+// TimeStyle enum.
+type TimeStyle int
+
+// TimeStyle kinds.
+const (
+	ET_STYLE_GO TimeStyle = iota
+	ET_STYLE_HHMMSS
+	ET_STYLE_HHMM
+	ET_STYLE_MMSS
+)
+
+// Statistics consists of progress related statistics, that Decorator
+// may need.
+type Statistics struct {
+	ID             int
+	AvailableWidth int
+	Total          int64
+	Current        int64
+	Refill         int64
+	Completed      bool
+}
+
+// Decorator interface.
+// Most of the time there is no need to implement this interface
+// manually, as decor package already provides a wide range of decorators
+// which implement this interface. If however built-in decorators don't
+// meet your needs, you're free to implement your own one by implementing
+// this particular interface. The easy way to go is to convert a
+// `DecorFunc` into a `Decorator` interface by using provided
+// `func Any(DecorFunc, ...WC) Decorator`.
+type Decorator interface {
+	Configurator
+	Synchronizer
+	Decor(Statistics) string
+}
+
+// DecorFunc func type.
+// To be used with `func Any`(DecorFunc, ...WC) Decorator`.
+type DecorFunc func(Statistics) string
+
+// Synchronizer interface.
+// All decorators implement this interface implicitly. Its Sync
+// method exposes width sync channel, if DSyncWidth bit is set.
+type Synchronizer interface {
+	Sync() (chan int, bool)
+}
+
+// Configurator interface.
+type Configurator interface {
+	GetConf() WC
+	SetConf(WC)
+}
+
+// Wrapper interface.
+// If you're implementing custom Decorator by wrapping a built-in one,
+// it is necessary to implement this interface to retain functionality
+// of built-in Decorator.
+type Wrapper interface {
+	Base() Decorator
+}
+
+// EwmaDecorator interface.
+// EWMA based decorators should implement this one.
+type EwmaDecorator interface {
+	EwmaUpdate(int64, time.Duration)
+}
+
+// AverageDecorator interface.
+// Average decorators should implement this interface to provide start
+// time adjustment facility, for resume-able tasks.
+type AverageDecorator interface {
+	AverageAdjust(time.Time)
+}
+
+// ShutdownListener interface.
+// If decorator needs to be notified once upon bar shutdown event, so
+// this is the right interface to implement.
+type ShutdownListener interface {
+	Shutdown()
+}
+
+// Global convenience instances of WC with sync width bit set.
+// To be used with multiple bars only, i.e. not effective for single bar usage.
+var (
+	WCSyncWidth  = WC{C: DSyncWidth}
+	WCSyncWidthR = WC{C: DSyncWidthR}
+	WCSyncSpace  = WC{C: DSyncSpace}
+	WCSyncSpaceR = WC{C: DSyncSpaceR}
+)
+
+// WC is a struct with two public fields W and C, both of int type.
+// W represents width and C represents bit set of width related config.
+// A decorator should embed WC, to enable width synchronization.
+type WC struct {
+	W     int
+	C     int
+	fill  func(s string, w int) string
+	wsync chan int
+}
+
+// FormatMsg formats final message according to WC.W and WC.C.
+// Should be called by any Decorator implementation.
+func (wc *WC) FormatMsg(msg string) string {
+	pureWidth := runewidth.StringWidth(msg)
+	stripWidth := runewidth.StringWidth(stripansi.Strip(msg))
+	maxCell := wc.W
+	if (wc.C & DSyncWidth) != 0 {
+		cellCount := stripWidth
+		if (wc.C & DextraSpace) != 0 {
+			cellCount++
+		}
+		wc.wsync <- cellCount
+		maxCell = <-wc.wsync
+	}
+	return wc.fill(msg, maxCell+(pureWidth-stripWidth))
+}
+
+// Init initializes width related config.
+func (wc *WC) Init() WC {
+	wc.fill = runewidth.FillLeft
+	if (wc.C & DidentRight) != 0 {
+		wc.fill = runewidth.FillRight
+	}
+	if (wc.C & DSyncWidth) != 0 {
+		// it's deliberate choice to override wsync on each Init() call,
+		// this way globals like WCSyncSpace can be reused
+		wc.wsync = make(chan int)
+	}
+	return *wc
+}
+
+// Sync is implementation of Synchronizer interface.
+func (wc *WC) Sync() (chan int, bool) {
+	if (wc.C&DSyncWidth) != 0 && wc.wsync == nil {
+		panic(fmt.Sprintf("%T is not initialized", wc))
+	}
+	return wc.wsync, (wc.C & DSyncWidth) != 0
+}
+
+// GetConf is implementation of Configurator interface.
+func (wc *WC) GetConf() WC {
+	return *wc
+}
+
+// SetConf is implementation of Configurator interface.
+func (wc *WC) SetConf(conf WC) {
+	*wc = conf.Init()
+}
+
+func initWC(wcc ...WC) WC {
+	var wc WC
+	for _, nwc := range wcc {
+		wc = nwc
+	}
+	return wc.Init()
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/doc.go b/vendor/github.com/vbauerster/mpb/v6/decor/doc.go
new file mode 100644
index 000000000..bfbb82e11
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/decor/doc.go
@@ -0,0 +1,20 @@
+// Package decor provides common decorators for "github.com/vbauerster/mpb/v6" module.
+/*
+ Some decorators returned by this package might have a closure state. It is ok to use
+ decorators concurrently, unless you share the same decorator among multiple
+ *mpb.Bar instances. To avoid data races, create new decorator per *mpb.Bar instance.
+
+ Don't:
+
+	 p := mpb.New()
+	 name := decor.Name("bar")
+	 p.AddBar(100, mpb.AppendDecorators(name))
+	 p.AddBar(100, mpb.AppendDecorators(name))
+
+ Do:
+
+	p := mpb.New()
+	p.AddBar(100, mpb.AppendDecorators(decor.Name("bar1")))
+	p.AddBar(100, mpb.AppendDecorators(decor.Name("bar2")))
+*/
+package decor
diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/elapsed.go b/vendor/github.com/vbauerster/mpb/v6/decor/elapsed.go
new file mode 100644
index 000000000..e389f1581
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/decor/elapsed.go
@@ -0,0 +1,35 @@
+package decor
+
+import (
+	"time"
+)
+
+// Elapsed decorator. It's wrapper of NewElapsed.
+//
+//	`style` one of [ET_STYLE_GO|ET_STYLE_HHMMSS|ET_STYLE_HHMM|ET_STYLE_MMSS]
+//
+//	`wcc` optional WC config
+//
+func Elapsed(style TimeStyle, wcc ...WC) Decorator {
+	return NewElapsed(style, time.Now(), wcc...)
+}
+
+// NewElapsed returns elapsed time decorator.
+//
+//	`style` one of [ET_STYLE_GO|ET_STYLE_HHMMSS|ET_STYLE_HHMM|ET_STYLE_MMSS]
+//
+//	`startTime` start time
+//
+//	`wcc` optional WC config
+//
+func NewElapsed(style TimeStyle, startTime time.Time, wcc ...WC) Decorator {
+	var msg string
+	producer := chooseTimeProducer(style)
+	fn := func(s Statistics) string {
+		if !s.Completed {
+			msg = producer(time.Since(startTime))
+		}
+		return msg
+	}
+	return Any(fn, wcc...)
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/eta.go b/vendor/github.com/vbauerster/mpb/v6/decor/eta.go
new file mode 100644
index 000000000..d03caa735
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/decor/eta.go
@@ -0,0 +1,203 @@
+package decor
+
+import (
+	"fmt"
+	"math"
+	"time"
+
+	"github.com/VividCortex/ewma"
+)
+
+// TimeNormalizer interface. Implementors could be passed into
+// MovingAverageETA, in order to affect i.e. normalize its output.
+type TimeNormalizer interface {
+	Normalize(time.Duration) time.Duration
+}
+
+// TimeNormalizerFunc is function type adapter to convert function
+// into TimeNormalizer.
+type TimeNormalizerFunc func(time.Duration) time.Duration
+
+func (f TimeNormalizerFunc) Normalize(src time.Duration) time.Duration {
+	return f(src)
+}
+
+// EwmaETA exponential-weighted-moving-average based ETA decorator.
+// For this decorator to work correctly you have to measure each
+// iteration's duration and pass it to the
+// *Bar.DecoratorEwmaUpdate(time.Duration) method after each increment.
+func EwmaETA(style TimeStyle, age float64, wcc ...WC) Decorator {
+	var average ewma.MovingAverage
+	if age == 0 {
+		average = ewma.NewMovingAverage()
+	} else {
+		average = ewma.NewMovingAverage(age)
+	}
+	return MovingAverageETA(style, NewThreadSafeMovingAverage(average), nil, wcc...)
+}
+
+// MovingAverageETA decorator relies on MovingAverage implementation to calculate its average.
+//
+//	`style` one of [ET_STYLE_GO|ET_STYLE_HHMMSS|ET_STYLE_HHMM|ET_STYLE_MMSS]
+//
+//	`average` implementation of MovingAverage interface
+//
+//	`normalizer` available implementations are [FixedIntervalTimeNormalizer|MaxTolerateTimeNormalizer]
+//
+//	`wcc` optional WC config
+//
+func MovingAverageETA(style TimeStyle, average ewma.MovingAverage, normalizer TimeNormalizer, wcc ...WC) Decorator {
+	d := &movingAverageETA{
+		WC:         initWC(wcc...),
+		average:    average,
+		normalizer: normalizer,
+		producer:   chooseTimeProducer(style),
+	}
+	return d
+}
+
+type movingAverageETA struct {
+	WC
+	average    ewma.MovingAverage
+	normalizer TimeNormalizer
+	producer   func(time.Duration) string
+}
+
+func (d *movingAverageETA) Decor(s Statistics) string {
+	v := math.Round(d.average.Value())
+	remaining := time.Duration((s.Total - s.Current) * int64(v))
+	if d.normalizer != nil {
+		remaining = d.normalizer.Normalize(remaining)
+	}
+	return d.FormatMsg(d.producer(remaining))
+}
+
+func (d *movingAverageETA) EwmaUpdate(n int64, dur time.Duration) {
+	durPerItem := float64(dur) / float64(n)
+	if math.IsInf(durPerItem, 0) || math.IsNaN(durPerItem) {
+		return
+	}
+	d.average.Add(durPerItem)
+}
+
+// AverageETA decorator. It's wrapper of NewAverageETA.
+//
+//	`style` one of [ET_STYLE_GO|ET_STYLE_HHMMSS|ET_STYLE_HHMM|ET_STYLE_MMSS]
+//
+//	`wcc` optional WC config
+//
+func AverageETA(style TimeStyle, wcc ...WC) Decorator {
+	return NewAverageETA(style, time.Now(), nil, wcc...)
+}
+
+// NewAverageETA decorator with user provided start time.
+//
+//	`style` one of [ET_STYLE_GO|ET_STYLE_HHMMSS|ET_STYLE_HHMM|ET_STYLE_MMSS]
+//
+//	`startTime` start time
+//
+//	`normalizer` available implementations are [FixedIntervalTimeNormalizer|MaxTolerateTimeNormalizer]
+//
+//	`wcc` optional WC config
+//
+func NewAverageETA(style TimeStyle, startTime time.Time, normalizer TimeNormalizer, wcc ...WC) Decorator {
+	d := &averageETA{
+		WC:         initWC(wcc...),
+		startTime:  startTime,
+		normalizer: normalizer,
+		producer:   chooseTimeProducer(style),
+	}
+	return d
+}
+
+type averageETA struct {
+	WC
+	startTime  time.Time
+	normalizer TimeNormalizer
+	producer   func(time.Duration) string
+}
+
+func (d *averageETA) Decor(s Statistics) string {
+	var remaining time.Duration
+	if s.Current != 0 {
+		durPerItem := float64(time.Since(d.startTime)) / float64(s.Current)
+		durPerItem = math.Round(durPerItem)
+		remaining = time.Duration((s.Total - s.Current) * int64(durPerItem))
+		if d.normalizer != nil {
+			remaining = d.normalizer.Normalize(remaining)
+		}
+	}
+	return d.FormatMsg(d.producer(remaining))
+}
+
+func (d *averageETA) AverageAdjust(startTime time.Time) {
+	d.startTime = startTime
+}
+
+// MaxTolerateTimeNormalizer returns implementation of TimeNormalizer.
+func MaxTolerateTimeNormalizer(maxTolerate time.Duration) TimeNormalizer {
+	var normalized time.Duration
+	var lastCall time.Time
+	return TimeNormalizerFunc(func(remaining time.Duration) time.Duration {
+		if diff := normalized - remaining; diff <= 0 || diff > maxTolerate || remaining < time.Minute {
+			normalized = remaining
+			lastCall = time.Now()
+			return remaining
+		}
+		normalized -= time.Since(lastCall)
+		lastCall = time.Now()
+		return normalized
+	})
+}
+
+// FixedIntervalTimeNormalizer returns implementation of TimeNormalizer.
+func FixedIntervalTimeNormalizer(updInterval int) TimeNormalizer {
+	var normalized time.Duration
+	var lastCall time.Time
+	var count int
+	return TimeNormalizerFunc(func(remaining time.Duration) time.Duration {
+		if count == 0 || remaining < time.Minute {
+			count = updInterval
+			normalized = remaining
+			lastCall = time.Now()
+			return remaining
+		}
+		count--
+		normalized -= time.Since(lastCall)
+		lastCall = time.Now()
+		return normalized
+	})
+}
+
+func chooseTimeProducer(style TimeStyle) func(time.Duration) string {
+	switch style {
+	case ET_STYLE_HHMMSS:
+		return func(remaining time.Duration) string {
+			hours := int64(remaining/time.Hour) % 60
+			minutes := int64(remaining/time.Minute) % 60
+			seconds := int64(remaining/time.Second) % 60
+			return fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
+		}
+	case ET_STYLE_HHMM:
+		return func(remaining time.Duration) string {
+			hours := int64(remaining/time.Hour) % 60
+			minutes := int64(remaining/time.Minute) % 60
+			return fmt.Sprintf("%02d:%02d", hours, minutes)
+		}
+	case ET_STYLE_MMSS:
+		return func(remaining time.Duration) string {
+			hours := int64(remaining/time.Hour) % 60
+			minutes := int64(remaining/time.Minute) % 60
+			seconds := int64(remaining/time.Second) % 60
+			if hours > 0 {
+				return fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
+			}
+			return fmt.Sprintf("%02d:%02d", minutes, seconds)
+		}
+	default:
+		return func(remaining time.Duration) string {
+			// strip off nanoseconds
+			return ((remaining / time.Second) * time.Second).String()
+		}
+	}
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/merge.go b/vendor/github.com/vbauerster/mpb/v6/decor/merge.go
new file mode 100644
index 000000000..e41406a64
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/decor/merge.go
@@ -0,0 +1,107 @@
+package decor
+
+import (
+	"strings"
+
+	"github.com/acarl005/stripansi"
+	"github.com/mattn/go-runewidth"
+)
+
+// Merge wraps its decorator argument with intention to sync width
+// with several decorators of another bar. Visual example:
+//
+//    +----+--------+---------+--------+
+//    | B1 |      MERGE(D, P1, Pn)     |
+//    +----+--------+---------+--------+
+//    | B2 |   D0   |   D1    |   Dn   |
+//    +----+--------+---------+--------+
+//
+func Merge(decorator Decorator, placeholders ...WC) Decorator {
+	if _, ok := decorator.Sync(); !ok || len(placeholders) == 0 {
+		return decorator
+	}
+	md := &mergeDecorator{
+		Decorator:    decorator,
+		wc:           decorator.GetConf(),
+		placeHolders: make([]*placeHolderDecorator, len(placeholders)),
+	}
+	decorator.SetConf(WC{})
+	for i, wc := range placeholders {
+		if (wc.C & DSyncWidth) == 0 {
+			return decorator
+		}
+		md.placeHolders[i] = &placeHolderDecorator{wc.Init()}
+	}
+	return md
+}
+
+type mergeDecorator struct {
+	Decorator
+	wc           WC
+	placeHolders []*placeHolderDecorator
+}
+
+func (d *mergeDecorator) GetConf() WC {
+	return d.wc
+}
+
+func (d *mergeDecorator) SetConf(conf WC) {
+	d.wc = conf.Init()
+}
+
+func (d *mergeDecorator) MergeUnwrap() []Decorator {
+	decorators := make([]Decorator, len(d.placeHolders))
+	for i, ph := range d.placeHolders {
+		decorators[i] = ph
+	}
+	return decorators
+}
+
+func (d *mergeDecorator) Sync() (chan int, bool) {
+	return d.wc.Sync()
+}
+
+func (d *mergeDecorator) Base() Decorator {
+	return d.Decorator
+}
+
+func (d *mergeDecorator) Decor(s Statistics) string {
+	msg := d.Decorator.Decor(s)
+	pureWidth := runewidth.StringWidth(msg)
+	stripWidth := runewidth.StringWidth(stripansi.Strip(msg))
+	cellCount := stripWidth
+	if (d.wc.C & DextraSpace) != 0 {
+		cellCount++
+	}
+
+	total := runewidth.StringWidth(d.placeHolders[0].FormatMsg(""))
+	pw := (cellCount - total) / len(d.placeHolders)
+	rem := (cellCount - total) % len(d.placeHolders)
+
+	var diff int
+	for i := 1; i < len(d.placeHolders); i++ {
+		ph := d.placeHolders[i]
+		width := pw - diff
+		if (ph.WC.C & DextraSpace) != 0 {
+			width--
+			if width < 0 {
+				width = 0
+			}
+		}
+		max := runewidth.StringWidth(ph.FormatMsg(strings.Repeat(" ", width)))
+		total += max
+		diff = max - pw
+	}
+
+	d.wc.wsync <- pw + rem
+	max := <-d.wc.wsync
+	return d.wc.fill(msg, max+total+(pureWidth-stripWidth))
+}
+
+type placeHolderDecorator struct {
+	WC
+}
+
+func (d *placeHolderDecorator) Decor(Statistics) string {
+	return ""
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/moving_average.go b/vendor/github.com/vbauerster/mpb/v6/decor/moving_average.go
new file mode 100644
index 000000000..50ac9c393
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/decor/moving_average.go
@@ -0,0 +1,68 @@
+package decor
+
+import (
+	"sort"
+	"sync"
+
+	"github.com/VividCortex/ewma"
+)
+
+type threadSafeMovingAverage struct {
+	ewma.MovingAverage
+	mu sync.Mutex
+}
+
+func (s *threadSafeMovingAverage) Add(value float64) {
+	s.mu.Lock()
+	s.MovingAverage.Add(value)
+	s.mu.Unlock()
+}
+
+func (s *threadSafeMovingAverage) Value() float64 {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.MovingAverage.Value()
+}
+
+func (s *threadSafeMovingAverage) Set(value float64) {
+	s.mu.Lock()
+	s.MovingAverage.Set(value)
+	s.mu.Unlock()
+}
+
+// NewThreadSafeMovingAverage converts provided ewma.MovingAverage
+// into thread safe ewma.MovingAverage.
+func NewThreadSafeMovingAverage(average ewma.MovingAverage) ewma.MovingAverage {
+	if tsma, ok := average.(*threadSafeMovingAverage); ok {
+		return tsma
+	}
+	return &threadSafeMovingAverage{MovingAverage: average}
+}
+
+type medianWindow [3]float64
+
+func (s *medianWindow) Len() int           { return len(s) }
+func (s *medianWindow) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+func (s *medianWindow) Less(i, j int) bool { return s[i] < s[j] }
+
+func (s *medianWindow) Add(value float64) {
+	s[0], s[1] = s[1], s[2]
+	s[2] = value
+}
+
+func (s *medianWindow) Value() float64 {
+	tmp := *s
+	sort.Sort(&tmp)
+	return tmp[1]
+}
+
+func (s *medianWindow) Set(value float64) {
+	for i := 0; i < len(s); i++ {
+		s[i] = value
+	}
+}
+
+// NewMedian is fixed last 3 samples median MovingAverage.
+func NewMedian() ewma.MovingAverage {
+	return NewThreadSafeMovingAverage(new(medianWindow))
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/name.go b/vendor/github.com/vbauerster/mpb/v6/decor/name.go
new file mode 100644
index 000000000..3af311254
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/decor/name.go
@@ -0,0 +1,12 @@
+package decor
+
+// Name decorator displays text that is set once and can't be changed
+// during decorator's lifetime.
+//
+//	`str` string to display
+//
+//	`wcc` optional WC config
+//
+func Name(str string, wcc ...WC) Decorator {
+	return Any(func(Statistics) string { return str }, wcc...)
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/on_complete.go b/vendor/github.com/vbauerster/mpb/v6/decor/on_complete.go
new file mode 100644
index 000000000..f46b19aba
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/decor/on_complete.go
@@ -0,0 +1,37 @@
+package decor
+
+// OnComplete returns decorator, which wraps provided decorator, with
+// sole purpose to display provided message on complete event.
+//
+//	`decorator` Decorator to wrap
+//
+//	`message` message to display on complete event
+//
+func OnComplete(decorator Decorator, message string) Decorator {
+	d := &onCompleteWrapper{
+		Decorator: decorator,
+		msg:       message,
+	}
+	if md, ok := decorator.(*mergeDecorator); ok {
+		d.Decorator, md.Decorator = md.Decorator, d
+		return md
+	}
+	return d
+}
+
+type onCompleteWrapper struct {
+	Decorator
+	msg string
+}
+
+func (d *onCompleteWrapper) Decor(s Statistics) string {
+	if s.Completed {
+		wc := d.GetConf()
+		return wc.FormatMsg(d.msg)
+	}
+	return d.Decorator.Decor(s)
+}
+
+func (d *onCompleteWrapper) Base() Decorator {
+	return d.Decorator
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/percentage.go b/vendor/github.com/vbauerster/mpb/v6/decor/percentage.go
new file mode 100644
index 000000000..f4922bb52
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/decor/percentage.go
@@ -0,0 +1,58 @@
+package decor
+
+import (
+	"fmt"
+	"io"
+	"strconv"
+
+	"github.com/vbauerster/mpb/v6/internal"
+)
+
+type percentageType float64
+
+func (s percentageType) Format(st fmt.State, verb rune) {
+	var prec int
+	switch verb {
+	case 'd':
+	case 's':
+		prec = -1
+	default:
+		if p, ok := st.Precision(); ok {
+			prec = p
+		} else {
+			prec = 6
+		}
+	}
+
+	io.WriteString(st, strconv.FormatFloat(float64(s), 'f', prec, 64))
+
+	if st.Flag(' ') {
+		io.WriteString(st, " ")
+	}
+	io.WriteString(st, "%")
+}
+
+// Percentage returns percentage decorator. It's a wrapper of NewPercentage.
+func Percentage(wcc ...WC) Decorator {
+	return NewPercentage("% d", wcc...)
+}
+
+// NewPercentage percentage decorator with custom format string.
+//
+// format examples:
+//
+//	format="%.1f"  output: "1.0%"
+//	format="% .1f" output: "1.0 %"
+//	format="%d"    output: "1%"
+//	format="% d"   output: "1 %"
+//
+func NewPercentage(format string, wcc ...WC) Decorator {
+	if format == "" {
+		format = "% d"
+	}
+	f := func(s Statistics) string {
+		p := internal.Percentage(s.Total, s.Current, 100)
+		return fmt.Sprintf(format, percentageType(p))
+	}
+	return Any(f, wcc...)
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/size_type.go b/vendor/github.com/vbauerster/mpb/v6/decor/size_type.go
new file mode 100644
index 000000000..e4b974058
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/decor/size_type.go
@@ -0,0 +1,109 @@
+package decor
+
+import (
+	"fmt"
+	"io"
+	"math"
+	"strconv"
+)
+
+//go:generate stringer -type=SizeB1024 -trimprefix=_i
+//go:generate stringer -type=SizeB1000 -trimprefix=_
+
+const (
+	_ib   SizeB1024 = iota + 1
+	_iKiB SizeB1024 = 1 << (iota * 10)
+	_iMiB
+	_iGiB
+	_iTiB
+)
+
+// SizeB1024 named type, which implements fmt.Formatter interface. It
+// adjusts its value according to byte size multiple by 1024 and appends
+// appropriate size marker (KiB, MiB, GiB, TiB).
+type SizeB1024 int64
+
+func (self SizeB1024) Format(st fmt.State, verb rune) {
+	var prec int
+	switch verb {
+	case 'd':
+	case 's':
+		prec = -1
+	default:
+		if p, ok := st.Precision(); ok {
+			prec = p
+		} else {
+			prec = 6
+		}
+	}
+
+	var unit SizeB1024
+	switch {
+	case self < _iKiB:
+		unit = _ib
+	case self < _iMiB:
+		unit = _iKiB
+	case self < _iGiB:
+		unit = _iMiB
+	case self < _iTiB:
+		unit = _iGiB
+	case self <= math.MaxInt64:
+		unit = _iTiB
+	}
+
+	io.WriteString(st, strconv.FormatFloat(float64(self)/float64(unit), 'f', prec, 64))
+
+	if st.Flag(' ') {
+		io.WriteString(st, " ")
+	}
+	io.WriteString(st, unit.String())
+}
+
+const (
+	_b  SizeB1000 = 1
+	_KB SizeB1000 = _b * 1000
+	_MB SizeB1000 = _KB * 1000
+	_GB SizeB1000 = _MB * 1000
+	_TB SizeB1000 = _GB * 1000
+)
+
+// SizeB1000 named type, which implements fmt.Formatter interface. It
+// adjusts its value according to byte size multiple by 1000 and appends
+// appropriate size marker (KB, MB, GB, TB).
+type SizeB1000 int64
+
+func (self SizeB1000) Format(st fmt.State, verb rune) {
+	var prec int
+	switch verb {
+	case 'd':
+	case 's':
+		prec = -1
+	default:
+		if p, ok := st.Precision(); ok {
+			prec = p
+		} else {
+			prec = 6
+		}
+	}
+
+	var unit SizeB1000
+	switch {
+	case self < _KB:
+		unit = _b
+	case self < _MB:
+		unit = _KB
+	case self < _GB:
+		unit = _MB
+	case self < _TB:
+		unit = _GB
+	case self <= math.MaxInt64:
+		unit = _TB
+	}
+
+	io.WriteString(st, strconv.FormatFloat(float64(self)/float64(unit), 'f', prec, 64))
+
+	if st.Flag(' ') {
+		io.WriteString(st, " ")
+	}
+	io.WriteString(st, unit.String())
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/sizeb1000_string.go b/vendor/github.com/vbauerster/mpb/v6/decor/sizeb1000_string.go
new file mode 100644
index 000000000..3f32ef715
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/decor/sizeb1000_string.go
@@ -0,0 +1,41 @@
+// Code generated by "stringer -type=SizeB1000 -trimprefix=_"; DO NOT EDIT.
+
+package decor
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[_b-1]
+	_ = x[_KB-1000]
+	_ = x[_MB-1000000]
+	_ = x[_GB-1000000000]
+	_ = x[_TB-1000000000000]
+}
+
+const (
+	_SizeB1000_name_0 = "b"
+	_SizeB1000_name_1 = "KB"
+	_SizeB1000_name_2 = "MB"
+	_SizeB1000_name_3 = "GB"
+	_SizeB1000_name_4 = "TB"
+)
+
+func (i SizeB1000) String() string {
+	switch {
+	case i == 1:
+		return _SizeB1000_name_0
+	case i == 1000:
+		return _SizeB1000_name_1
+	case i == 1000000:
+		return _SizeB1000_name_2
+	case i == 1000000000:
+		return _SizeB1000_name_3
+	case i == 1000000000000:
+		return _SizeB1000_name_4
+	default:
+		return "SizeB1000(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/sizeb1024_string.go b/vendor/github.com/vbauerster/mpb/v6/decor/sizeb1024_string.go
new file mode 100644
index 000000000..9fca66cc7
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/decor/sizeb1024_string.go
@@ -0,0 +1,41 @@
+// Code generated by "stringer -type=SizeB1024 -trimprefix=_i"; DO NOT EDIT.
+
+package decor
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[_ib-1]
+	_ = x[_iKiB-1024]
+	_ = x[_iMiB-1048576]
+	_ = x[_iGiB-1073741824]
+	_ = x[_iTiB-1099511627776]
+}
+
+const (
+	_SizeB1024_name_0 = "b"
+	_SizeB1024_name_1 = "KiB"
+	_SizeB1024_name_2 = "MiB"
+	_SizeB1024_name_3 = "GiB"
+	_SizeB1024_name_4 = "TiB"
+)
+
+func (i SizeB1024) String() string {
+	switch {
+	case i == 1:
+		return _SizeB1024_name_0
+	case i == 1024:
+		return _SizeB1024_name_1
+	case i == 1048576:
+		return _SizeB1024_name_2
+	case i == 1073741824:
+		return _SizeB1024_name_3
+	case i == 1099511627776:
+		return _SizeB1024_name_4
+	default:
+		return "SizeB1024(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/speed.go b/vendor/github.com/vbauerster/mpb/v6/decor/speed.go
new file mode 100644
index 000000000..634edabfd
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/decor/speed.go
@@ -0,0 +1,171 @@
+package decor
+
+import (
+	"fmt"
+	"io"
+	"math"
+	"time"
+
+	"github.com/VividCortex/ewma"
+)
+
+// FmtAsSpeed adds "/s" to the end of the input formatter. To be
+// used with SizeB1000 or SizeB1024 types, for example:
+//
+//	fmt.Printf("%.1f", FmtAsSpeed(SizeB1024(2048)))
+//
+func FmtAsSpeed(input fmt.Formatter) fmt.Formatter {
+	return &speedFormatter{input}
+}
+
+type speedFormatter struct {
+	fmt.Formatter
+}
+
+func (self *speedFormatter) Format(st fmt.State, verb rune) {
+	self.Formatter.Format(st, verb)
+	io.WriteString(st, "/s")
+}
+
+// EwmaSpeed exponential-weighted-moving-average based speed decorator.
+// For this decorator to work correctly you have to measure each
+// iteration's duration and pass it to the
+// *Bar.DecoratorEwmaUpdate(time.Duration) method after each increment.
+func EwmaSpeed(unit int, format string, age float64, wcc ...WC) Decorator {
+	var average ewma.MovingAverage
+	if age == 0 {
+		average = ewma.NewMovingAverage()
+	} else {
+		average = ewma.NewMovingAverage(age)
+	}
+	return MovingAverageSpeed(unit, format, NewThreadSafeMovingAverage(average), wcc...)
+}
+
+// MovingAverageSpeed decorator relies on MovingAverage implementation
+// to calculate its average.
+//
+//	`unit` one of [0|UnitKiB|UnitKB] zero for no unit
+//
+//	`format` printf compatible verb for value, like "%f" or "%d"
+//
+//	`average` MovingAverage implementation
+//
+//	`wcc` optional WC config
+//
+// format examples:
+//
+//	unit=UnitKiB, format="%.1f"  output: "1.0MiB/s"
+//	unit=UnitKiB, format="% .1f" output: "1.0 MiB/s"
+//	unit=UnitKB,  format="%.1f"  output: "1.0MB/s"
+//	unit=UnitKB,  format="% .1f" output: "1.0 MB/s"
+//
+func MovingAverageSpeed(unit int, format string, average ewma.MovingAverage, wcc ...WC) Decorator {
+	if format == "" {
+		format = "%.0f"
+	}
+	d := &movingAverageSpeed{
+		WC:       initWC(wcc...),
+		average:  average,
+		producer: chooseSpeedProducer(unit, format),
+	}
+	return d
+}
+
+type movingAverageSpeed struct {
+	WC
+	producer func(float64) string
+	average  ewma.MovingAverage
+	msg      string
+}
+
+func (d *movingAverageSpeed) Decor(s Statistics) string {
+	if !s.Completed {
+		var speed float64
+		if v := d.average.Value(); v > 0 {
+			speed = 1 / v
+		}
+		d.msg = d.producer(speed * 1e9)
+	}
+	return d.FormatMsg(d.msg)
+}
+
+func (d *movingAverageSpeed) EwmaUpdate(n int64, dur time.Duration) {
+	durPerByte := float64(dur) / float64(n)
+	if math.IsInf(durPerByte, 0) || math.IsNaN(durPerByte) {
+		return
+	}
+	d.average.Add(durPerByte)
+}
+
+// AverageSpeed decorator with dynamic unit measure adjustment. It's
+// a wrapper of NewAverageSpeed.
+func AverageSpeed(unit int, format string, wcc ...WC) Decorator {
+	return NewAverageSpeed(unit, format, time.Now(), wcc...)
+}
+
+// NewAverageSpeed decorator with dynamic unit measure adjustment and
+// user provided start time.
+//
+//	`unit` one of [0|UnitKiB|UnitKB] zero for no unit
+//
+//	`format` printf compatible verb for value, like "%f" or "%d"
+//
+//	`startTime` start time
+//
+//	`wcc` optional WC config
+//
+// format examples:
+//
+//	unit=UnitKiB, format="%.1f"  output: "1.0MiB/s"
+//	unit=UnitKiB, format="% .1f" output: "1.0 MiB/s"
+//	unit=UnitKB,  format="%.1f"  output: "1.0MB/s"
+//	unit=UnitKB,  format="% .1f" output: "1.0 MB/s"
+//
+func NewAverageSpeed(unit int, format string, startTime time.Time, wcc ...WC) Decorator {
+	if format == "" {
+		format = "%.0f"
+	}
+	d := &averageSpeed{
+		WC:        initWC(wcc...),
+		startTime: startTime,
+		producer:  chooseSpeedProducer(unit, format),
+	}
+	return d
+}
+
+type averageSpeed struct {
+	WC
+	startTime time.Time
+	producer  func(float64) string
+	msg       string
+}
+
+func (d *averageSpeed) Decor(s Statistics) string {
+	if !s.Completed {
+		speed := float64(s.Current) / float64(time.Since(d.startTime))
+		d.msg = d.producer(speed * 1e9)
+	}
+
+	return d.FormatMsg(d.msg)
+}
+
+func (d *averageSpeed) AverageAdjust(startTime time.Time) {
+	d.startTime = startTime
+}
+
+func chooseSpeedProducer(unit int, format string) func(float64) string {
+	switch unit {
+	case UnitKiB:
+		return func(speed float64) string {
+			return fmt.Sprintf(format, FmtAsSpeed(SizeB1024(math.Round(speed))))
+		}
+	case UnitKB:
+		return func(speed float64) string {
+			return fmt.Sprintf(format, FmtAsSpeed(SizeB1000(math.Round(speed))))
+		}
+	default:
+		return func(speed float64) string {
+			return fmt.Sprintf(format, speed)
+		}
+	}
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/spinner.go b/vendor/github.com/vbauerster/mpb/v6/decor/spinner.go
new file mode 100644
index 000000000..6871639db
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/decor/spinner.go
@@ -0,0 +1,21 @@
+package decor
+
+var defaultSpinnerStyle = []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
+
+// Spinner returns spinner decorator.
+//
+//	`frames` spinner frames, if nil or len==0, default is used
+//
+//	`wcc` optional WC config
+func Spinner(frames []string, wcc ...WC) Decorator {
+	if len(frames) == 0 {
+		frames = defaultSpinnerStyle
+	}
+	var count uint
+	f := func(s Statistics) string {
+		frame := frames[count%uint(len(frames))]
+		count++
+		return frame
+	}
+	return Any(f, wcc...)
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/doc.go b/vendor/github.com/vbauerster/mpb/v6/doc.go
new file mode 100644
index 000000000..5ada71774
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/doc.go
@@ -0,0 +1,2 @@
+// Package mpb is a library for rendering progress bars in terminal applications.
+package mpb
diff --git a/vendor/github.com/vbauerster/mpb/v6/go.mod b/vendor/github.com/vbauerster/mpb/v6/go.mod
new file mode 100644
index 000000000..3a3d337d2
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/go.mod
@@ -0,0 +1,11 @@
+module github.com/vbauerster/mpb/v6
+
+require (
+	github.com/VividCortex/ewma v1.1.1
+	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d
+	github.com/mattn/go-runewidth v0.0.10
+	github.com/rivo/uniseg v0.2.0
+	golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78
+)
+
+go 1.14
diff --git a/vendor/github.com/vbauerster/mpb/v6/go.sum b/vendor/github.com/vbauerster/mpb/v6/go.sum
new file mode 100644
index 000000000..1c20f8921
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/go.sum
@@ -0,0 +1,11 @@
+github.com/VividCortex/ewma v1.1.1 h1:MnEK4VOv6n0RSY4vtRe3h11qjxL3+t0B8yOL8iMXdcM=
+github.com/VividCortex/ewma v1.1.1/go.mod h1:2Tkkvm3sRDVXaiyucHiACn4cqf7DpdyLvmxzcbUokwA=
+github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d h1:licZJFw2RwpHMqeKTCYkitsPqHNxTmd4SNR5r94FGM8=
+github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d/go.mod h1:asat636LX7Bqt5lYEZ27JNDcqxfjdBQuJ/MM4CN/Lzo=
+github.com/mattn/go-runewidth v0.0.10 h1:CoZ3S2P7pvtP45xOtBw+/mDL2z0RKI576gSkzRRpdGg=
+github.com/mattn/go-runewidth v0.0.10/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
+github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78 h1:nVuTkr9L6Bq62qpUqKo/RnZCFfzDBL0bYo6w9OJUqZY=
+golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
diff --git a/vendor/github.com/vbauerster/mpb/v6/internal/percentage.go b/vendor/github.com/vbauerster/mpb/v6/internal/percentage.go
new file mode 100644
index 000000000..a8ef8be12
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/internal/percentage.go
@@ -0,0 +1,19 @@
+package internal
+
+import "math"
+
+// Percentage is a helper function, to calculate percentage.
+func Percentage(total, current int64, width int) float64 {
+	if total <= 0 {
+		return 0
+	}
+	if current >= total {
+		return float64(width)
+	}
+	return float64(int64(width)*current) / float64(total)
+}
+
+// PercentageRound same as Percentage but with math.Round.
+func PercentageRound(total, current int64, width int) float64 {
+	return math.Round(Percentage(total, current, width))
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/internal/predicate.go b/vendor/github.com/vbauerster/mpb/v6/internal/predicate.go
new file mode 100644
index 000000000..1e4dd24d9
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/internal/predicate.go
@@ -0,0 +1,6 @@
+package internal
+
+// Predicate helper for internal use.
+func Predicate(pick bool) func() bool {
+	return func() bool { return pick }
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/internal/width.go b/vendor/github.com/vbauerster/mpb/v6/internal/width.go
new file mode 100644
index 000000000..216320f24
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/internal/width.go
@@ -0,0 +1,10 @@
+package internal
+
+// CheckRequestedWidth checks that requested width doesn't overflow
+// available width
+func CheckRequestedWidth(requested, available int) int {
+	if requested <= 0 || requested >= available {
+		return available
+	}
+	return requested
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/priority_queue.go b/vendor/github.com/vbauerster/mpb/v6/priority_queue.go
new file mode 100644
index 000000000..29d9bd5a8
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/priority_queue.go
@@ -0,0 +1,32 @@
+package mpb
+
+// A priorityQueue implements heap.Interface
+type priorityQueue []*Bar
+
+func (pq priorityQueue) Len() int { return len(pq) }
+
+func (pq priorityQueue) Less(i, j int) bool {
+	return pq[i].priority < pq[j].priority
+}
+
+func (pq priorityQueue) Swap(i, j int) {
+	pq[i], pq[j] = pq[j], pq[i]
+	pq[i].index = i
+	pq[j].index = j
+}
+
+func (pq *priorityQueue) Push(x interface{}) {
+	s := *pq
+	bar := x.(*Bar)
+	bar.index = len(s)
+	s = append(s, bar)
+	*pq = s
+}
+
+func (pq *priorityQueue) Pop() interface{} {
+	s := *pq
+	*pq = s[0 : len(s)-1]
+	bar := s[len(s)-1]
+	bar.index = -1 // for safety
+	return bar
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/progress.go b/vendor/github.com/vbauerster/mpb/v6/progress.go
new file mode 100644
index 000000000..5a3f96243
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/progress.go
@@ -0,0 +1,412 @@
+package mpb
+
+import (
+	"bytes"
+	"container/heap"
+	"context"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"math"
+	"os"
+	"sync"
+	"time"
+
+	"github.com/vbauerster/mpb/v6/cwriter"
+	"github.com/vbauerster/mpb/v6/decor"
+)
+
+const (
+	// default RefreshRate
+	prr = 120 * time.Millisecond
+)
+
+// Progress represents a container that renders one or more progress
+// bars.
+type Progress struct {
+	ctx          context.Context
+	uwg          *sync.WaitGroup
+	cwg          *sync.WaitGroup
+	bwg          *sync.WaitGroup
+	operateState chan func(*pState)
+	done         chan struct{}
+	refreshCh    chan time.Time
+	once         sync.Once
+	dlogger      *log.Logger
+}
+
+// pState holds bars in its priorityQueue. It gets passed to
+// *Progress.serve(...) monitor goroutine.
+type pState struct {
+	bHeap            priorityQueue
+	heapUpdated      bool
+	pMatrix          map[int][]chan int
+	aMatrix          map[int][]chan int
+	barShutdownQueue []*Bar
+
+	// following are provided/overrided by user
+	idCount          int
+	reqWidth         int
+	popCompleted     bool
+	outputDiscarded  bool
+	rr               time.Duration
+	uwg              *sync.WaitGroup
+	externalRefresh  <-chan interface{}
+	renderDelay      <-chan struct{}
+	shutdownNotifier chan struct{}
+	parkedBars       map[*Bar]*Bar
+	output           io.Writer
+	debugOut         io.Writer
+}
+
+// New creates new Progress container instance. It's not possible to
+// reuse instance after *Progress.Wait() method has been called.
+func New(options ...ContainerOption) *Progress {
+	return NewWithContext(context.Background(), options...)
+}
+
+// NewWithContext creates new Progress container instance with provided
+// context. It's not possible to reuse instance after *Progress.Wait()
+// method has been called.
+func NewWithContext(ctx context.Context, options ...ContainerOption) *Progress {
+	s := &pState{
+		bHeap:      priorityQueue{},
+		rr:         prr,
+		parkedBars: make(map[*Bar]*Bar),
+		output:     os.Stdout,
+		debugOut:   ioutil.Discard,
+	}
+
+	for _, opt := range options {
+		if opt != nil {
+			opt(s)
+		}
+	}
+
+	p := &Progress{
+		ctx:          ctx,
+		uwg:          s.uwg,
+		cwg:          new(sync.WaitGroup),
+		bwg:          new(sync.WaitGroup),
+		operateState: make(chan func(*pState)),
+		done:         make(chan struct{}),
+		dlogger:      log.New(s.debugOut, "[mpb] ", log.Lshortfile),
+	}
+
+	p.cwg.Add(1)
+	go p.serve(s, cwriter.New(s.output))
+	return p
+}
+
+// AddBar creates a bar with default bar filler. Different filler can
+// be choosen and applied via `*Progress.Add(...) *Bar` method.
+func (p *Progress) AddBar(total int64, options ...BarOption) *Bar {
+	return p.Add(total, NewBarFiller(BarDefaultStyle), options...)
+}
+
+// AddSpinner creates a bar with default spinner filler. Different
+// filler can be choosen and applied via `*Progress.Add(...) *Bar`
+// method.
+func (p *Progress) AddSpinner(total int64, alignment SpinnerAlignment, options ...BarOption) *Bar {
+	return p.Add(total, NewSpinnerFiller(SpinnerDefaultStyle, alignment), options...)
+}
+
+// Add creates a bar which renders itself by provided filler.
+// If `total <= 0` trigger complete event is disabled until reset with *bar.SetTotal(int64, bool).
+// Panics if *Progress instance is done, i.e. called after *Progress.Wait().
+func (p *Progress) Add(total int64, filler BarFiller, options ...BarOption) *Bar {
+	if filler == nil {
+		filler = BarFillerFunc(func(io.Writer, int, decor.Statistics) {})
+	}
+	p.bwg.Add(1)
+	result := make(chan *Bar)
+	select {
+	case p.operateState <- func(ps *pState) {
+		bs := ps.makeBarState(total, filler, options...)
+		bar := newBar(p, bs)
+		if bs.runningBar != nil {
+			bs.runningBar.noPop = true
+			ps.parkedBars[bs.runningBar] = bar
+		} else {
+			heap.Push(&ps.bHeap, bar)
+			ps.heapUpdated = true
+		}
+		ps.idCount++
+		result <- bar
+	}:
+		bar := <-result
+		bar.subscribeDecorators()
+		return bar
+	case <-p.done:
+		p.bwg.Done()
+		panic(fmt.Sprintf("%T instance can't be reused after it's done!", p))
+	}
+}
+
+func (p *Progress) dropBar(b *Bar) {
+	select {
+	case p.operateState <- func(s *pState) {
+		if b.index < 0 {
+			return
+		}
+		heap.Remove(&s.bHeap, b.index)
+		s.heapUpdated = true
+	}:
+	case <-p.done:
+	}
+}
+
+func (p *Progress) setBarPriority(b *Bar, priority int) {
+	select {
+	case p.operateState <- func(s *pState) {
+		if b.index < 0 {
+			return
+		}
+		b.priority = priority
+		heap.Fix(&s.bHeap, b.index)
+	}:
+	case <-p.done:
+	}
+}
+
+// UpdateBarPriority same as *Bar.SetPriority(int).
+func (p *Progress) UpdateBarPriority(b *Bar, priority int) {
+	p.setBarPriority(b, priority)
+}
+
+// BarCount returns bars count.
+func (p *Progress) BarCount() int {
+	result := make(chan int, 1)
+	select {
+	case p.operateState <- func(s *pState) { result <- s.bHeap.Len() }:
+		return <-result
+	case <-p.done:
+		return 0
+	}
+}
+
+// Wait waits for all bars to complete and finally shutdowns container.
+// After this method has been called, there is no way to reuse *Progress
+// instance.
+func (p *Progress) Wait() {
+	if p.uwg != nil {
+		// wait for user wg
+		p.uwg.Wait()
+	}
+
+	// wait for bars to quit, if any
+	p.bwg.Wait()
+
+	p.once.Do(p.shutdown)
+
+	// wait for container to quit
+	p.cwg.Wait()
+}
+
+func (p *Progress) shutdown() {
+	close(p.done)
+}
+
+func (p *Progress) serve(s *pState, cw *cwriter.Writer) {
+	defer p.cwg.Done()
+
+	p.refreshCh = s.newTicker(p.done)
+
+	for {
+		select {
+		case op := <-p.operateState:
+			op(s)
+		case <-p.refreshCh:
+			if err := s.render(cw); err != nil {
+				p.dlogger.Println(err)
+			}
+		case <-s.shutdownNotifier:
+			if s.heapUpdated {
+				if err := s.render(cw); err != nil {
+					p.dlogger.Println(err)
+				}
+			}
+			return
+		}
+	}
+}
+
+func (s *pState) newTicker(done <-chan struct{}) chan time.Time {
+	ch := make(chan time.Time)
+	if s.shutdownNotifier == nil {
+		s.shutdownNotifier = make(chan struct{})
+	}
+	go func() {
+		if s.renderDelay != nil {
+			<-s.renderDelay
+		}
+		var internalRefresh <-chan time.Time
+		if !s.outputDiscarded {
+			if s.externalRefresh == nil {
+				ticker := time.NewTicker(s.rr)
+				defer ticker.Stop()
+				internalRefresh = ticker.C
+			}
+		} else {
+			s.externalRefresh = nil
+		}
+		for {
+			select {
+			case t := <-internalRefresh:
+				ch <- t
+			case x := <-s.externalRefresh:
+				if t, ok := x.(time.Time); ok {
+					ch <- t
+				} else {
+					ch <- time.Now()
+				}
+			case <-done:
+				close(s.shutdownNotifier)
+				return
+			}
+		}
+	}()
+	return ch
+}
+
+func (s *pState) render(cw *cwriter.Writer) error {
+	if s.heapUpdated {
+		s.updateSyncMatrix()
+		s.heapUpdated = false
+	}
+	syncWidth(s.pMatrix)
+	syncWidth(s.aMatrix)
+
+	tw, err := cw.GetWidth()
+	if err != nil {
+		tw = s.reqWidth
+	}
+	for i := 0; i < s.bHeap.Len(); i++ {
+		bar := s.bHeap[i]
+		go bar.render(tw)
+	}
+
+	return s.flush(cw)
+}
+
+func (s *pState) flush(cw *cwriter.Writer) error {
+	var lineCount int
+	bm := make(map[*Bar]struct{}, s.bHeap.Len())
+	for s.bHeap.Len() > 0 {
+		b := heap.Pop(&s.bHeap).(*Bar)
+		cw.ReadFrom(<-b.frameCh)
+		if b.toShutdown {
+			if b.recoveredPanic != nil {
+				s.barShutdownQueue = append(s.barShutdownQueue, b)
+				b.toShutdown = false
+			} else {
+				// shutdown at next flush
+				// this ensures no bar ends up with less than 100% rendered
+				defer func() {
+					s.barShutdownQueue = append(s.barShutdownQueue, b)
+				}()
+			}
+		}
+		lineCount += b.extendedLines + 1
+		bm[b] = struct{}{}
+	}
+
+	for _, b := range s.barShutdownQueue {
+		if parkedBar := s.parkedBars[b]; parkedBar != nil {
+			parkedBar.priority = b.priority
+			heap.Push(&s.bHeap, parkedBar)
+			delete(s.parkedBars, b)
+			b.toDrop = true
+		}
+		if s.popCompleted && !b.noPop {
+			lineCount -= b.extendedLines + 1
+			b.toDrop = true
+		}
+		if b.toDrop {
+			delete(bm, b)
+			s.heapUpdated = true
+		}
+		b.cancel()
+	}
+	s.barShutdownQueue = s.barShutdownQueue[0:0]
+
+	for b := range bm {
+		heap.Push(&s.bHeap, b)
+	}
+
+	return cw.Flush(lineCount)
+}
+
+func (s *pState) updateSyncMatrix() {
+	s.pMatrix = make(map[int][]chan int)
+	s.aMatrix = make(map[int][]chan int)
+	for i := 0; i < s.bHeap.Len(); i++ {
+		bar := s.bHeap[i]
+		table := bar.wSyncTable()
+		pRow, aRow := table[0], table[1]
+
+		for i, ch := range pRow {
+			s.pMatrix[i] = append(s.pMatrix[i], ch)
+		}
+
+		for i, ch := range aRow {
+			s.aMatrix[i] = append(s.aMatrix[i], ch)
+		}
+	}
+}
+
+func (s *pState) makeBarState(total int64, filler BarFiller, options ...BarOption) *bState {
+	bs := &bState{
+		id:       s.idCount,
+		priority: s.idCount,
+		reqWidth: s.reqWidth,
+		total:    total,
+		filler:   filler,
+		extender: func(r io.Reader, _ int, _ decor.Statistics) (io.Reader, int) { return r, 0 },
+		debugOut: s.debugOut,
+	}
+
+	if total > 0 {
+		bs.triggerComplete = true
+	}
+
+	for _, opt := range options {
+		if opt != nil {
+			opt(bs)
+		}
+	}
+
+	if bs.middleware != nil {
+		bs.filler = bs.middleware(filler)
+		bs.middleware = nil
+	}
+
+	if s.popCompleted && !bs.noPop {
+		bs.priority = -(math.MaxInt32 - s.idCount)
+	}
+
+	bs.bufP = bytes.NewBuffer(make([]byte, 0, 128))
+	bs.bufB = bytes.NewBuffer(make([]byte, 0, 256))
+	bs.bufA = bytes.NewBuffer(make([]byte, 0, 128))
+
+	return bs
+}
+
+func syncWidth(matrix map[int][]chan int) {
+	for _, column := range matrix {
+		go maxWidthDistributor(column)
+	}
+}
+
+var maxWidthDistributor = func(column []chan int) {
+	var maxWidth int
+	for _, ch := range column {
+		if w := <-ch; w > maxWidth {
+			maxWidth = w
+		}
+	}
+	for _, ch := range column {
+		ch <- maxWidth
+	}
+}
diff --git a/vendor/github.com/vbauerster/mpb/v6/proxyreader.go b/vendor/github.com/vbauerster/mpb/v6/proxyreader.go
new file mode 100644
index 000000000..316f438d7
--- /dev/null
+++ b/vendor/github.com/vbauerster/mpb/v6/proxyreader.go
@@ -0,0 +1,90 @@
+package mpb
+
+import (
+	"io"
+	"io/ioutil"
+	"time"
+)
+
+type proxyReader struct {
+	io.ReadCloser
+	bar *Bar
+}
+
+func (x *proxyReader) Read(p []byte) (int, error) {
+	n, err := x.ReadCloser.Read(p)
+	x.bar.IncrBy(n)
+	if err == io.EOF {
+		go x.bar.SetTotal(0, true)
+	}
+	return n, err
+}
+
+type proxyWriterTo struct {
+	io.ReadCloser // *proxyReader
+	wt            io.WriterTo
+	bar           *Bar
+}
+
+func (x *proxyWriterTo) WriteTo(w io.Writer) (int64, error) {
+	n, err := x.wt.WriteTo(w)
+	x.bar.IncrInt64(n)
+	if err == io.EOF {
+		go x.bar.SetTotal(0, true)
+	}
+	return n, err
+}
+
+type ewmaProxyReader struct {
+	io.ReadCloser // *proxyReader
+	bar           *Bar
+	iT            time.Time
+}
+
+func (x *ewmaProxyReader) Read(p []byte) (int, error) {
+	n, err := x.ReadCloser.Read(p)
+	if n > 0 {
+		x.bar.DecoratorEwmaUpdate(time.Since(x.iT))
+		x.iT = time.Now()
+	}
+	return n, err
+}
+
+type ewmaProxyWriterTo struct {
+	io.ReadCloser             // *ewmaProxyReader
+	wt            io.WriterTo // *proxyWriterTo
+	bar           *Bar
+	iT            time.Time
+}
+
+func (x *ewmaProxyWriterTo) WriteTo(w io.Writer) (int64, error) {
+	n, err := x.wt.WriteTo(w)
+	if n > 0 {
+		x.bar.DecoratorEwmaUpdate(time.Since(x.iT))
+		x.iT = time.Now()
+	}
+	return n, err
+}
+
+func newProxyReader(r io.Reader, bar *Bar) io.ReadCloser {
+	rc := toReadCloser(r)
+	rc = &proxyReader{rc, bar}
+
+	if wt, isWriterTo := r.(io.WriterTo); bar.hasEwmaDecorators {
+		now := time.Now()
+		rc = &ewmaProxyReader{rc, bar, now}
+		if isWriterTo {
+			rc = &ewmaProxyWriterTo{rc, wt, bar, now}
+		}
+	} else if isWriterTo {
+		rc = &proxyWriterTo{rc, wt, bar}
+	}
+	return rc
+}
+
+func toReadCloser(r io.Reader) io.ReadCloser {
+	if rc, ok := r.(io.ReadCloser); ok {
+		return rc
+	}
+	return ioutil.NopCloser(r)
+}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 22a2ece0a..0b2fca535 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -240,12 +240,24 @@ github.com/coreos/go-systemd/v22/dbus
 github.com/coreos/go-systemd/v22/internal/dlopen
 github.com/coreos/go-systemd/v22/journal
 github.com/coreos/go-systemd/v22/sdjournal
+# github.com/coreos/stream-metadata-go v0.0.0-20210225230131-70edb9eb47b3
+github.com/coreos/stream-metadata-go/fedoracoreos
+github.com/coreos/stream-metadata-go/fedoracoreos/internals
+github.com/coreos/stream-metadata-go/stream
+github.com/coreos/stream-metadata-go/stream/rhcos
 # github.com/cri-o/ocicni v0.2.1-0.20210301205850-541cf7c703cf
 github.com/cri-o/ocicni/pkg/ocicni
 # github.com/cyphar/filepath-securejoin v0.2.2
 github.com/cyphar/filepath-securejoin
 # github.com/davecgh/go-spew v1.1.1
 github.com/davecgh/go-spew/spew
+# github.com/digitalocean/go-libvirt v0.0.0-20201209184759-e2a69bcd5bd1
+github.com/digitalocean/go-libvirt
+github.com/digitalocean/go-libvirt/internal/constants
+github.com/digitalocean/go-libvirt/internal/event
+github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2
+# github.com/digitalocean/go-qemu v0.0.0-20210209191958-152a1535e49f
+github.com/digitalocean/go-qemu/qmp
 # github.com/docker/distribution v2.7.1+incompatible
 github.com/docker/distribution
 github.com/docker/distribution/digestset
@@ -572,6 +584,11 @@ github.com/vbauerster/mpb/v5
 github.com/vbauerster/mpb/v5/cwriter
 github.com/vbauerster/mpb/v5/decor
 github.com/vbauerster/mpb/v5/internal
+# github.com/vbauerster/mpb/v6 v6.0.2
+github.com/vbauerster/mpb/v6
+github.com/vbauerster/mpb/v6/cwriter
+github.com/vbauerster/mpb/v6/decor
+github.com/vbauerster/mpb/v6/internal
 # github.com/vishvananda/netlink v1.1.1-0.20201029203352-d40f9887b852
 github.com/vishvananda/netlink
 github.com/vishvananda/netlink/nl