Merge pull request #9781 from baude/addqemu

introduce podman machine

122 files changed, 31151 insertions, 22 deletions

diff --git a/cmd/podman/common/completion.go b/cmd/podman/common/completion.go
index bc106263c..6bed5e0c6 100644
--- a/cmd/podman/common/completion.go
+++ b/cmd/podman/common/completion.go
@@ -1092,3 +1092,11 @@ func AutocompleteVolumeFilters(cmd *cobra.Command, args []string, toComplete str
 	}
 	return completeKeyValues(toComplete, kv)
 }
+
+// AutocompleteMachineSSH - Autocomplete machine ssh command.
+func AutocompleteMachineSSH(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	if len(args) == 0 {
+		return nil, cobra.ShellCompDirectiveNoFileComp
+	}
+	return nil, cobra.ShellCompDirectiveDefault
+}
diff --git a/cmd/podman/machine/create.go b/cmd/podman/machine/create.go
new file mode 100644
index 000000000..1da34327a
--- /dev/null
+++ b/cmd/podman/machine/create.go
@@ -0,0 +1,99 @@
+// +build amd64,linux amd64,darwin arm64,darwin
+
+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/spf13/cobra"
+)
+
+var (
+	createCmd = &cobra.Command{
+		Use:               "create [options] [NAME]",
+		Short:             "Create a vm",
+		Long:              "Create a virtual machine for Podman to run on. Virtual machines are used to run Podman.",
+		RunE:              create,
+		Args:              cobra.MaximumNArgs(1),
+		Example:           `podman machine create myvm`,
+		ValidArgsFunction: completion.AutocompleteNone,
+	}
+)
+
+type CreateCLIOptions struct {
+	CPUS         uint64
+	Memory       uint64
+	Devices      []string
+	ImagePath    string
+	IgnitionPath string
+	Name         string
+}
+
+var (
+	createOpts                = CreateCLIOptions{}
+	defaultMachineName string = "podman-machine-default"
+)
+
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: createCmd,
+		Parent:  machineCmd,
+	})
+	flags := createCmd.Flags()
+
+	cpusFlagName := "cpus"
+	flags.Uint64Var(
+		&createOpts.CPUS,
+		cpusFlagName, 1,
+		"Number of CPUs. The default is 0.000 which means no limit",
+	)
+	_ = createCmd.RegisterFlagCompletionFunc(cpusFlagName, completion.AutocompleteNone)
+
+	memoryFlagName := "memory"
+	flags.Uint64VarP(
+		&createOpts.Memory,
+		memoryFlagName, "m", 2048,
+		"Memory (in MB)",
+	)
+	_ = createCmd.RegisterFlagCompletionFunc(memoryFlagName, completion.AutocompleteNone)
+
+	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 {
+	createOpts.Name = defaultMachineName
+	if len(args) > 0 {
+		createOpts.Name = args[0]
+	}
+	vmOpts := machine.CreateOptions{
+		CPUS:         createOpts.CPUS,
+		Memory:       createOpts.Memory,
+		IgnitionPath: createOpts.IgnitionPath,
+		ImagePath:    createOpts.ImagePath,
+		Name:         createOpts.Name,
+	}
+	var (
+		vm     machine.VM
+		vmType string
+		err    error
+	)
+	switch vmType {
+	default: // qemu is the default
+		vm, err = qemu.NewMachine(vmOpts)
+	}
+	if err != nil {
+		return err
+	}
+	return vm.Create(vmOpts)
+}
diff --git a/cmd/podman/machine/machine.go b/cmd/podman/machine/machine.go
new file mode 100644
index 000000000..ed284ee10
--- /dev/null
+++ b/cmd/podman/machine/machine.go
@@ -0,0 +1,32 @@
+// +build amd64,linux amd64,darwin arm64,darwin
+
+package machine
+
+import (
+	"github.com/containers/podman/v3/cmd/podman/registry"
+	"github.com/containers/podman/v3/cmd/podman/validate"
+	"github.com/containers/podman/v3/pkg/domain/entities"
+	"github.com/spf13/cobra"
+)
+
+var (
+	noOp = func(cmd *cobra.Command, args []string) error {
+		return nil
+	}
+	// Command: podman _machine_
+	machineCmd = &cobra.Command{
+		Use:                "machine",
+		Short:              "Manage a virtual machine",
+		Long:               "Manage a virtual machine. Virtual machines are used to run Podman.",
+		PersistentPreRunE:  noOp,
+		PersistentPostRunE: noOp,
+		RunE:               validate.SubCommandExists,
+	}
+)
+
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: machineCmd,
+	})
+}
diff --git a/cmd/podman/machine/machine_unsupported.go b/cmd/podman/machine/machine_unsupported.go
new file mode 100644
index 000000000..cb1636419
--- /dev/null
+++ b/cmd/podman/machine/machine_unsupported.go
@@ -0,0 +1,5 @@
+// +build !amd64 arm64,linux amd64,windows
+
+package machine
+
+func init() {}
diff --git a/cmd/podman/machine/remove.go b/cmd/podman/machine/remove.go
new file mode 100644
index 000000000..f6ce9e326
--- /dev/null
+++ b/cmd/podman/machine/remove.go
@@ -0,0 +1,88 @@
+// +build amd64,linux amd64,darwin arm64,darwin
+
+package machine
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"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/spf13/cobra"
+)
+
+var (
+	removeCmd = &cobra.Command{
+		Use:               "remove [options] NAME",
+		Short:             "Remove an existing machine",
+		Long:              "Remove an existing machine ",
+		RunE:              remove,
+		Args:              cobra.ExactArgs(1),
+		Example:           `podman machine remove myvm`,
+		ValidArgsFunction: completion.AutocompleteNone,
+	}
+)
+
+var (
+	destoryOptions machine.RemoveOptions
+)
+
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: removeCmd,
+		Parent:  machineCmd,
+	})
+
+	flags := removeCmd.Flags()
+	formatFlagName := "force"
+	flags.BoolVar(&destoryOptions.Force, formatFlagName, false, "Do not prompt before removeing")
+
+	keysFlagName := "save-keys"
+	flags.BoolVar(&destoryOptions.SaveKeys, keysFlagName, false, "Do not delete SSH keys")
+
+	ignitionFlagName := "save-ignition"
+	flags.BoolVar(&destoryOptions.SaveIgnition, ignitionFlagName, false, "Do not delete ignition file")
+
+	imageFlagName := "save-image"
+	flags.BoolVar(&destoryOptions.SaveImage, imageFlagName, false, "Do not delete the image file")
+}
+
+func remove(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.Remove(args[0], machine.RemoveOptions{})
+	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..a7111a195
--- /dev/null
+++ b/cmd/podman/machine/ssh.go
@@ -0,0 +1,70 @@
+// +build amd64,linux amd64,darwin arm64,darwin
+
+package machine
+
+import (
+	"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/pkg/errors"
+	"github.com/spf13/cobra"
+)
+
+var (
+	sshCmd = &cobra.Command{
+		Use:   "ssh [options] NAME [COMMAND [ARG ...]]",
+		Short: "SSH into a virtual machine",
+		Long:  "SSH into a virtual machine ",
+		RunE:  ssh,
+		Args:  cobra.MinimumNArgs(1),
+		Example: `podman machine ssh myvm
+  podman machine ssh -e  myvm echo hello`,
+
+		ValidArgsFunction: common.AutocompleteMachineSSH,
+	}
+)
+
+var (
+	sshOpts machine.SSHOptions
+)
+
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: sshCmd,
+		Parent:  machineCmd,
+	})
+
+	flags := sshCmd.Flags()
+	executeFlagName := "execute"
+	flags.BoolVarP(&sshOpts.Execute, executeFlagName, "e", false, "Execute command from args")
+}
+
+func ssh(cmd *cobra.Command, args []string) error {
+	var (
+		err    error
+		vm     machine.VM
+		vmType string
+	)
+	sshOpts.Args = args[1:]
+
+	// Error if no execute but args given
+	if !sshOpts.Execute && len(sshOpts.Args) > 0 {
+		return errors.New("too many args: to execute commands via ssh, use -e flag")
+	}
+	// Error if execute but no args given
+	if sshOpts.Execute && len(sshOpts.Args) < 1 {
+		return errors.New("must proivde at least one command to execute")
+	}
+
+	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], sshOpts)
+}
diff --git a/cmd/podman/machine/start.go b/cmd/podman/machine/start.go
new file mode 100644
index 000000000..44ade2850
--- /dev/null
+++ b/cmd/podman/machine/start.go
@@ -0,0 +1,48 @@
+// +build amd64,linux amd64,darwin arm64,darwin
+
+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/spf13/cobra"
+)
+
+var (
+	startCmd = &cobra.Command{
+		Use:               "start NAME",
+		Short:             "Start an existing machine",
+		Long:              "Start an existing machine ",
+		RunE:              start,
+		Args:              cobra.ExactArgs(1),
+		Example:           `podman machine start myvm`,
+		ValidArgsFunction: completion.AutocompleteNone,
+	}
+)
+
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: startCmd,
+		Parent:  machineCmd,
+	})
+}
+
+func start(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
+	}
+	return vm.Start(args[0], machine.StartOptions{})
+}
diff --git a/cmd/podman/machine/stop.go b/cmd/podman/machine/stop.go
new file mode 100644
index 000000000..35fd4ff95
--- /dev/null
+++ b/cmd/podman/machine/stop.go
@@ -0,0 +1,49 @@
+// +build amd64,linux amd64,darwin arm64,darwin
+
+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/spf13/cobra"
+)
+
+var (
+	stopCmd = &cobra.Command{
+		Use:               "stop NAME",
+		Short:             "Stop an existing machine",
+		Long:              "Stop an existing machine ",
+		RunE:              stop,
+		Args:              cobra.ExactArgs(1),
+		Example:           `podman machine stop myvm`,
+		ValidArgsFunction: completion.AutocompleteNone,
+	}
+)
+
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: stopCmd,
+		Parent:  machineCmd,
+	})
+}
+
+// TODO  Name shouldnt be required, need to create a default vm
+func stop(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
+	}
+	return vm.Stop(args[0], machine.StopOptions{})
+}
diff --git a/cmd/podman/main.go b/cmd/podman/main.go
index 561459c31..5219da26d 100644
--- a/cmd/podman/main.go
+++ b/cmd/podman/main.go
@@ -9,6 +9,7 @@ import (
 	_ "github.com/containers/podman/v3/cmd/podman/generate"
 	_ "github.com/containers/podman/v3/cmd/podman/healthcheck"
 	_ "github.com/containers/podman/v3/cmd/podman/images"
+	_ "github.com/containers/podman/v3/cmd/podman/machine"
 	_ "github.com/containers/podman/v3/cmd/podman/manifest"
 	_ "github.com/containers/podman/v3/cmd/podman/networks"
 	_ "github.com/containers/podman/v3/cmd/podman/play"
diff --git a/docs/source/Commands.rst b/docs/source/Commands.rst
index 0bb23f71b..766b6a02e 100644
--- a/docs/source/Commands.rst
+++ b/docs/source/Commands.rst
@@ -55,6 +55,8 @@ Commands
 
 :doc:`logs <markdown/podman-logs.1>` Fetch the logs of a container
 
+:doc:`machine <markdown/podman-machine.1>` Manage podman's virtual machine
+
 :doc:`manifest <manifest>` Create and manipulate manifest lists and image indexes
 
 :doc:`mount <markdown/podman-mount.1>` Mount a working container's root filesystem
diff --git a/docs/source/machine.rst b/docs/source/machine.rst
new file mode 100644
index 000000000..cf7f72cce
--- /dev/null
+++ b/docs/source/machine.rst
@@ -0,0 +1,9 @@
+Machine
+======
+
+
+:doc:`create <markdown/podman-machine-create.1>` Create a new virtual machine
+:doc:`remove <markdown/podman-machine-remove.1>` Remove 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
new file mode 100644
index 000000000..eb498f2dd
--- /dev/null
+++ b/docs/source/markdown/podman-machine-create.1.md
@@ -0,0 +1,53 @@
+% podman-machine-create(1)
+
+## NAME
+podman\-machine\-create - Create a new virtual machine
+
+## SYNOPSIS
+**podman machine create** [*options*] [*name*]
+
+## DESCRIPTION
+
+Creates a new virtual machine for Podman.
+
+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.
+
+**podman machine create** creates a new Linux virtual machine where containers are run.
+
+## OPTIONS
+
+#### **--cpus**=*number*
+
+Number of CPUs.
+
+#### **--ignition-path**
+
+Fully qualified path of the ignition file
+
+#### **--image-path**
+
+Fully qualified path of the uncompressed image file
+
+#### **--memory**, **-m**=*number*
+
+Memory (in MB).
+
+#### **--help**
+
+Print usage statement.
+
+## EXAMPLES
+
+```
+$ podman machine create myvm
+$ podman machine create --device=/dev/xvdc:rw myvm
+$ podman machine create --memory=1024 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-remove.1.md b/docs/source/markdown/podman-machine-remove.1.md
new file mode 100644
index 000000000..07763741d
--- /dev/null
+++ b/docs/source/markdown/podman-machine-remove.1.md
@@ -0,0 +1,65 @@
+% podman-machine-remove(1)
+
+## NAME
+podman\-machine\-remove - Remove a virtual machine
+
+## SYNOPSIS
+**podman machine remove** [*options*] *name*
+
+## DESCRIPTION
+
+Remove 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 removeed 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
+
+Remove a VM named "test1"
+
+```
+$ podman machine remove 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..bcecd1010
--- /dev/null
+++ b/docs/source/markdown/podman-machine-ssh.1.md
@@ -0,0 +1,43 @@
+% podman-machine-ssh(1)
+
+## NAME
+podman\-machine\-ssh - SSH into a virtual machine
+
+## SYNOPSIS
+**podman machine ssh** [*options*] *name* [*command* [*arg* ...]]
+
+## 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
+
+#### **--execute**, **-e**
+
+Execute the given command on the VM
+
+#### **--help**
+
+Print usage statement.
+
+## EXAMPLES
+
+To get an interactive session with a VM called `myvm`:
+```
+$ podman machine ssh myvm
+```
+
+To run a command on a VM called `myvm`:
+```
+$ podman machine ssh -e myvm -- rpm -q podman
+```
+
+## SEE ALSO
+podman-machine (1)
+
+## HISTORY
+March 2021, Originally compiled by Ashley Cui <acui@redhat.com>
diff --git a/docs/source/markdown/podman-machine-start.1.md b/docs/source/markdown/podman-machine-start.1.md
new file mode 100644
index 000000000..511296b11
--- /dev/null
+++ b/docs/source/markdown/podman-machine-start.1.md
@@ -0,0 +1,35 @@
+% podman-machine-start(1)
+
+## NAME
+podman\-machine\-start - Start a virtual machine
+
+## SYNOPSIS
+**podman machine start** *name*
+
+## DESCRIPTION
+
+Starts a virtual machine for Podman.
+
+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.
+
+**podman machine start** starts a Linux virtual machine where containers are run.
+
+## OPTIONS
+
+#### **--help**
+
+Print usage statement.
+
+## EXAMPLES
+
+```
+$ podman machine start 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-stop.1.md b/docs/source/markdown/podman-machine-stop.1.md
new file mode 100644
index 000000000..62439cbb1
--- /dev/null
+++ b/docs/source/markdown/podman-machine-stop.1.md
@@ -0,0 +1,35 @@
+% podman-machine-stop(1)
+
+## NAME
+podman\-machine\-stop - Stop a virtual machine
+
+## SYNOPSIS
+**podman machine stop** *name*
+
+## DESCRIPTION
+
+Stops a 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.
+
+**podman machine stop** stops a Linux virtual machine where containers are run.
+
+## OPTIONS
+
+#### **--help**
+
+Print usage statement.
+
+## EXAMPLES
+
+```
+$ podman machine stop 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
new file mode 100644
index 000000000..52f212cdd
--- /dev/null
+++ b/docs/source/markdown/podman-machine.1.md
@@ -0,0 +1,26 @@
+% podman-machine(1)
+
+## NAME
+podman\-machine - Manage Podman's virtual machine
+
+## SYNOPSIS
+**podman machine** *subcommand*
+
+## DESCRIPTION
+`podman machine` is a set of subcommands that manage Podman's virtual machine on MacOS.
+
+## SUBCOMMANDS
+
+| Command | Man Page                                                | Description                   |
+| ------- | ------------------------------------------------------- | ----------------------------- |
+| create  | [podman-machine-create(1)](podman-machine-create.1.md)  | Create a new virtual machine  |
+| remove | [podman-machine-destroy(1)](podman-machine-remove.1.md)| Remove 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        |
+
+## SEE ALSO
+podman(1)
+
+## HISTORY
+March 2021, Originally compiled by Ashley Cui <acui@redhat.com>
diff --git a/docs/source/markdown/podman.1.md b/docs/source/markdown/podman.1.md
index 141d231f3..7bf7aa210 100644
--- a/docs/source/markdown/podman.1.md
+++ b/docs/source/markdown/podman.1.md
@@ -237,6 +237,7 @@ the exit codes follow the `chroot` standard, see below:
 | [podman-login(1)](podman-login.1.md)             | Login to a container registry.                                              |
 | [podman-logout(1)](podman-logout.1.md)           | Logout of a container registry.                                             |
 | [podman-logs(1)](podman-logs.1.md)               | Display the logs of one or more containers.                                 |
+| [podman-machine(1)](podman-machine.1.md)         | Manage Podman's virtual machine                                             |
 | [podman-manifest(1)](podman-manifest.1.md)       | Create and manipulate manifest lists and image indexes.                     |
 | [podman-mount(1)](podman-mount.1.md)             | Mount a working container's root filesystem.                                |
 | [podman-network(1)](podman-network.1.md)         | Manage Podman CNI networks.                                                 |
diff --git a/go.mod b/go.mod
index b904e3a17..385c571b1 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.1
 	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 047d6d8c1..501673496 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=
@@ -209,6 +210,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=
@@ -219,7 +221,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=
@@ -241,6 +246,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=
@@ -282,6 +291,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=
@@ -772,6 +782,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=
@@ -793,6 +805,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=
@@ -893,6 +906,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=
@@ -989,6 +1003,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=
@@ -1046,6 +1062,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/machine/config.go b/pkg/machine/config.go
new file mode 100644
index 000000000..242401ab4
--- /dev/null
+++ b/pkg/machine/config.go
@@ -0,0 +1,120 @@
+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 {
+	Execute bool
+	Args    []string
+}
+type StartOptions struct{}
+
+type StopOptions struct{}
+
+type RemoveOptions struct {
+	Force        bool
+	SaveKeys     bool
+	SaveImage    bool
+	SaveIgnition bool
+}
+
+type VM interface {
+	Create(opts CreateOptions) error
+	Remove(name string, opts RemoveOptions) (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
+}
+
+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:   "",
+	}
+	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..0c6a2485e
--- /dev/null
+++ b/pkg/machine/fcos.go
@@ -0,0 +1,160 @@
+package machine
+
+import (
+	"crypto/sha256"
+	"io"
+	"io/ioutil"
+	url2 "net/url"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"github.com/containers/storage/pkg/archive"
+	digest "github.com/opencontainers/go-digest"
+	"github.com/sirupsen/logrus"
+)
+
+// 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..504b64bd5
--- /dev/null
+++ b/pkg/machine/qemu/machine.go
@@ -0,0 +1,317 @@
+package qemu
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"time"
+
+	"github.com/containers/podman/v3/utils"
+
+	"github.com/containers/podman/v3/pkg/machine"
+	"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 := utils.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
+	logrus.Debug(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 := getSocketDir()
+	if err != nil {
+		return Monitor{}, err
+	}
+	rtDir = filepath.Join(rtDir, "podman")
+	if _, err := os.Stat(filepath.Join(rtDir)); os.IsNotExist(err) {
+		// TODO 0644 is fine on linux but macos is weird
+		if err := os.MkdirAll(rtDir, 0755); err != nil {
+			return Monitor{}, err
+		}
+	}
+	if timeout == 0 {
+		timeout = defaultQMPTimeout
+	}
+	monitor := Monitor{
+		Network: network,
+		Address: filepath.Join(rtDir, "qmp_"+name+".sock"),
+		Timeout: timeout,
+	}
+	return monitor, nil
+}
+
+func (v *MachineVM) Remove(name string, opts machine.RemoveOptions) (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)
+
+	args := []string{"-i", v.IdentityPath, "-p", port, sshDestination}
+	if opts.Execute {
+		args = append(args, opts.Args...)
+	} else {
+		fmt.Printf("Connecting to vm %s. To close connection, use `~.` or `exit`\n", v.Name)
+	}
+
+	cmd := exec.Command("ssh", args...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Stdin = os.Stdin
+
+	return cmd.Run()
+}
diff --git a/pkg/machine/qemu/options_darwin.go b/pkg/machine/qemu/options_darwin.go
new file mode 100644
index 000000000..46ccf24cb
--- /dev/null
+++ b/pkg/machine/qemu/options_darwin.go
@@ -0,0 +1,15 @@
+package qemu
+
+import (
+	"os"
+
+	"github.com/pkg/errors"
+)
+
+func getSocketDir() (string, error) {
+	tmpDir, ok := os.LookupEnv("TMPDIR")
+	if !ok {
+		return "", errors.New("unable to resolve TMPDIR")
+	}
+	return tmpDir, nil
+}
diff --git a/pkg/machine/qemu/options_darwin_amd64.go b/pkg/machine/qemu/options_darwin_amd64.go
new file mode 100644
index 000000000..69f7982b2
--- /dev/null
+++ b/pkg/machine/qemu/options_darwin_amd64.go
@@ -0,0 +1,18 @@
+package qemu
+
+var (
+	QemuCommand = "qemu-system-x86_64"
+)
+
+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{}
+}
diff --git a/pkg/machine/qemu/options_darwin_arm64.go b/pkg/machine/qemu/options_darwin_arm64.go
new file mode 100644
index 000000000..7513b3048
--- /dev/null
+++ b/pkg/machine/qemu/options_darwin_arm64.go
@@ -0,0 +1,36 @@
+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 getOvmfDir(imagePath, vmName string) string {
+	return filepath.Join(filepath.Dir(imagePath), vmName+"_ovmf_vars.fd")
+}
diff --git a/pkg/machine/qemu/options_linux.go b/pkg/machine/qemu/options_linux.go
new file mode 100644
index 000000000..0a2e40d8f
--- /dev/null
+++ b/pkg/machine/qemu/options_linux.go
@@ -0,0 +1,7 @@
+package qemu
+
+import "github.com/containers/podman/v3/pkg/util"
+
+func getSocketDir() (string, error) {
+	return util.GetRuntimeDir()
+}
diff --git a/pkg/machine/qemu/options_linux_amd64.go b/pkg/machine/qemu/options_linux_amd64.go
new file mode 100644
index 000000000..cc0a4bab2
--- /dev/null
+++ b/pkg/machine/qemu/options_linux_amd64.go
@@ -0,0 +1,18 @@
+package qemu
+
+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{}
+}
diff --git a/pkg/specgen/generate/ports.go b/pkg/specgen/generate/ports.go
index 6cf83ed81..678e36a70 100644
--- a/pkg/specgen/generate/ports.go
+++ b/pkg/specgen/generate/ports.go
@@ -6,6 +6,8 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v3/utils"
+
 	"github.com/containers/podman/v3/libpod/image"
 	"github.com/containers/podman/v3/pkg/specgen"
 	"github.com/cri-o/ocicni/pkg/ocicni"
@@ -218,7 +220,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 = utils.GetRandomPort()
 					if err != nil {
 						return nil, nil, nil, errors.Wrapf(err, "error getting candidate host port for container port %d", p.ContainerPort)
 					}
@@ -344,7 +346,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 := utils.GetRandomPort()
 				if err != nil {
 					return nil, err
 				}
@@ -419,21 +421,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/utils/ports.go b/utils/ports.go
new file mode 100644
index 000000000..0a4f67dcc
--- /dev/null
+++ b/utils/ports.go
@@ -0,0 +1,26 @@
+package utils
+
+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 32fb1b54a..eb58bd54f 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