libvirt

type CloudInitDisk struct {
	pulumi.CustomResourceState

	// cloud-init user data.
	MetaData pulumi.StringPtrOutput `pulumi:"metaData"`
	// A unique name for the resource, required by libvirt.
	Name pulumi.StringOutput `pulumi:"name"`
	// cloud-init network-config data.
	NetworkConfig pulumi.StringPtrOutput `pulumi:"networkConfig"`
	// The pool where the resource will be created.
	// If not given, the `default` pool will be used.
	// For user_data, networkConfig and metaData parameters have a look at upstream doc:
	// http://cloudinit.readthedocs.io/en/latest/topics/datasources/nocloud.html#datasource-nocloud
	Pool pulumi.StringPtrOutput `pulumi:"pool"`
	// cloud-init user data.
	UserData pulumi.StringPtrOutput `pulumi:"userData"`
}

type CloudInitDiskArgs struct {
	// cloud-init user data.
	MetaData pulumi.StringPtrInput
	// A unique name for the resource, required by libvirt.
	Name pulumi.StringPtrInput
	// cloud-init network-config data.
	NetworkConfig pulumi.StringPtrInput
	// The pool where the resource will be created.
	// If not given, the `default` pool will be used.
	// For user_data, networkConfig and metaData parameters have a look at upstream doc:
	// http://cloudinit.readthedocs.io/en/latest/topics/datasources/nocloud.html#datasource-nocloud
	Pool pulumi.StringPtrInput
	// cloud-init user data.
	UserData pulumi.StringPtrInput
}

type CloudInitDiskArray []CloudInitDiskInput

type CloudInitDiskArrayInput interface {
	pulumi.Input

	ToCloudInitDiskArrayOutput() CloudInitDiskArrayOutput
	ToCloudInitDiskArrayOutputWithContext(context.Context) CloudInitDiskArrayOutput
}

type CloudInitDiskArrayOutput struct{ *pulumi.OutputState }

type CloudInitDiskInput interface {
	pulumi.Input

	ToCloudInitDiskOutput() CloudInitDiskOutput
	ToCloudInitDiskOutputWithContext(ctx context.Context) CloudInitDiskOutput
}

type CloudInitDiskMap map[string]CloudInitDiskInput

type CloudInitDiskMapInput interface {
	pulumi.Input

	ToCloudInitDiskMapOutput() CloudInitDiskMapOutput
	ToCloudInitDiskMapOutputWithContext(context.Context) CloudInitDiskMapOutput
}

type CloudInitDiskMapOutput struct{ *pulumi.OutputState }

type CloudInitDiskOutput struct{ *pulumi.OutputState }

type CloudInitDiskState struct {
	// cloud-init user data.
	MetaData pulumi.StringPtrInput
	// A unique name for the resource, required by libvirt.
	Name pulumi.StringPtrInput
	// cloud-init network-config data.
	NetworkConfig pulumi.StringPtrInput
	// The pool where the resource will be created.
	// If not given, the `default` pool will be used.
	// For user_data, networkConfig and metaData parameters have a look at upstream doc:
	// http://cloudinit.readthedocs.io/en/latest/topics/datasources/nocloud.html#datasource-nocloud
	Pool pulumi.StringPtrInput
	// cloud-init user data.
	UserData pulumi.StringPtrInput
}

type Combustion struct {
	pulumi.CustomResourceState

	Content pulumi.StringOutput    `pulumi:"content"`
	Name    pulumi.StringOutput    `pulumi:"name"`
	Pool    pulumi.StringPtrOutput `pulumi:"pool"`
}

type CombustionArgs struct {
	Content pulumi.StringInput
	Name    pulumi.StringPtrInput
	Pool    pulumi.StringPtrInput
}

type CombustionArray []CombustionInput

type CombustionArrayInput interface {
	pulumi.Input

	ToCombustionArrayOutput() CombustionArrayOutput
	ToCombustionArrayOutputWithContext(context.Context) CombustionArrayOutput
}

type CombustionArrayOutput struct{ *pulumi.OutputState }

type CombustionInput interface {
	pulumi.Input

	ToCombustionOutput() CombustionOutput
	ToCombustionOutputWithContext(ctx context.Context) CombustionOutput
}

type CombustionMap map[string]CombustionInput

type CombustionMapInput interface {
	pulumi.Input

	ToCombustionMapOutput() CombustionMapOutput
	ToCombustionMapOutputWithContext(context.Context) CombustionMapOutput
}

type CombustionMapOutput struct{ *pulumi.OutputState }

type CombustionOutput struct{ *pulumi.OutputState }

type CombustionState struct {
	Content pulumi.StringPtrInput
	Name    pulumi.StringPtrInput
	Pool    pulumi.StringPtrInput
}

type Domain struct {
	pulumi.CustomResourceState

	// The architecture for the VM (probably x8664 or i686),
	// you normally won't need to set this unless you are building a special VM
	Arch pulumi.StringOutput `pulumi:"arch"`
	// Set to `true` to start the domain on host boot up.
	// If not specified `false` is assumed.
	Autostart pulumi.BoolOutput `pulumi:"autostart"`
	// A list of devices (dev) which defines boot order. Example
	// below.
	BootDevices DomainBootDeviceArrayOutput `pulumi:"bootDevices"`
	// The `CloudInitDisk` disk that has to be used by
	// the domain. This is going to be attached as a CDROM ISO. Changing the
	// cloud-init won't cause the domain to be recreated, however the change will
	// have effect on the next reboot.
	Cloudinit pulumi.StringPtrOutput      `pulumi:"cloudinit"`
	Cmdlines  pulumi.StringMapArrayOutput `pulumi:"cmdlines"`
	Consoles  DomainConsoleArrayOutput    `pulumi:"consoles"`
	// The
	// [Ignition](https://www.terraform.io/docs/providers/libvirt/r/coreos_ignition.html) resource
	// that is to be used by the CoreOS domain.
	CoreosIgnition pulumi.StringPtrOutput `pulumi:"coreosIgnition"`
	// Configures CPU mode. See below for more
	// details.
	Cpu DomainCpuOutput `pulumi:"cpu"`
	// The description for domain.
	// Changing this forces a new resource to be created.
	// This data is not used by libvirt in any way, it can contain any information the user wants.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// An array of one or more disks to attach to the domain. The
	// `disk` object structure is documented below.
	Disks DomainDiskArrayOutput `pulumi:"disks"`
	// The path of the emulator to use
	Emulator pulumi.StringOutput `pulumi:"emulator"`
	// An array of one or more host filesystems to attach to
	// the domain. The `filesystem` object structure is documented
	// below.
	Filesystems DomainFilesystemArrayOutput `pulumi:"filesystems"`
	Firmware    pulumi.StringPtrOutput      `pulumi:"firmware"`
	// The name of the firmware config path where ignition file is stored: default is `opt/com.coreos/config`. If you are using [Flatcar Linux](https://docs.flatcar-linux.org/os/booting-with-libvirt/#creating-the-domain-xml), the value is `opt/org.flatcar-linux/config`.
	FwCfgName pulumi.StringPtrOutput  `pulumi:"fwCfgName"`
	Graphics  DomainGraphicsPtrOutput `pulumi:"graphics"`
	Initrd    pulumi.StringPtrOutput  `pulumi:"initrd"`
	Kernel    pulumi.StringPtrOutput  `pulumi:"kernel"`
	// The machine type,
	// you normally won't need to set this unless you are running on a platform that
	// defaults to the wrong machine type for your template
	Machine pulumi.StringOutput `pulumi:"machine"`
	// The amount of memory in MiB. If not specified the domain
	// will be created with 512 MiB of memory be used.
	Memory   pulumi.IntPtrOutput    `pulumi:"memory"`
	Metadata pulumi.StringPtrOutput `pulumi:"metadata"`
	// A unique name for the resource, required by libvirt.
	// Changing this forces a new resource to be created.
	Name pulumi.StringOutput `pulumi:"name"`
	// An array of one or more network interfaces to
	// attach to the domain. The `networkInterface` object structure is documented
	// below.
	NetworkInterfaces DomainNetworkInterfaceArrayOutput `pulumi:"networkInterfaces"`
	Nvram             DomainNvramOutput                 `pulumi:"nvram"`
	// By default is disabled, set to true for enabling it. More info [qemu-agent](https://wiki.libvirt.org/page/Qemu_guest_agent).
	QemuAgent pulumi.BoolPtrOutput `pulumi:"qemuAgent"`
	// Use `false` to turn off the instance. If not specified,
	// true is assumed and the instance, if stopped, will be started at next apply.
	Running pulumi.BoolPtrOutput `pulumi:"running"`
	// TPM device to attach to the domain. The `tpm` object structure is documented below.
	Tpm DomainTpmPtrOutput `pulumi:"tpm"`
	// The type of hypervisor to use for the domain.  Defaults to `kvm`, other values can be found [here](https://libvirt.org/formatdomain.html#id1)
	Type pulumi.StringPtrOutput `pulumi:"type"`
	// The amount of virtual CPUs. If not specified, a single CPU
	// will be created.
	Vcpu  pulumi.IntPtrOutput  `pulumi:"vcpu"`
	Video DomainVideoPtrOutput `pulumi:"video"`
	Xml   DomainXmlPtrOutput   `pulumi:"xml"`
}

type DomainArgs struct {
	// The architecture for the VM (probably x8664 or i686),
	// you normally won't need to set this unless you are building a special VM
	Arch pulumi.StringPtrInput
	// Set to `true` to start the domain on host boot up.
	// If not specified `false` is assumed.
	Autostart pulumi.BoolPtrInput
	// A list of devices (dev) which defines boot order. Example
	// below.
	BootDevices DomainBootDeviceArrayInput
	// The `CloudInitDisk` disk that has to be used by
	// the domain. This is going to be attached as a CDROM ISO. Changing the
	// cloud-init won't cause the domain to be recreated, however the change will
	// have effect on the next reboot.
	Cloudinit pulumi.StringPtrInput
	Cmdlines  pulumi.StringMapArrayInput
	Consoles  DomainConsoleArrayInput
	// The
	// [Ignition](https://www.terraform.io/docs/providers/libvirt/r/coreos_ignition.html) resource
	// that is to be used by the CoreOS domain.
	CoreosIgnition pulumi.StringPtrInput
	// Configures CPU mode. See below for more
	// details.
	Cpu DomainCpuPtrInput
	// The description for domain.
	// Changing this forces a new resource to be created.
	// This data is not used by libvirt in any way, it can contain any information the user wants.
	Description pulumi.StringPtrInput
	// An array of one or more disks to attach to the domain. The
	// `disk` object structure is documented below.
	Disks DomainDiskArrayInput
	// The path of the emulator to use
	Emulator pulumi.StringPtrInput
	// An array of one or more host filesystems to attach to
	// the domain. The `filesystem` object structure is documented
	// below.
	Filesystems DomainFilesystemArrayInput
	Firmware    pulumi.StringPtrInput
	// The name of the firmware config path where ignition file is stored: default is `opt/com.coreos/config`. If you are using [Flatcar Linux](https://docs.flatcar-linux.org/os/booting-with-libvirt/#creating-the-domain-xml), the value is `opt/org.flatcar-linux/config`.
	FwCfgName pulumi.StringPtrInput
	Graphics  DomainGraphicsPtrInput
	Initrd    pulumi.StringPtrInput
	Kernel    pulumi.StringPtrInput
	// The machine type,
	// you normally won't need to set this unless you are running on a platform that
	// defaults to the wrong machine type for your template
	Machine pulumi.StringPtrInput
	// The amount of memory in MiB. If not specified the domain
	// will be created with 512 MiB of memory be used.
	Memory   pulumi.IntPtrInput
	Metadata pulumi.StringPtrInput
	// A unique name for the resource, required by libvirt.
	// Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// An array of one or more network interfaces to
	// attach to the domain. The `networkInterface` object structure is documented
	// below.
	NetworkInterfaces DomainNetworkInterfaceArrayInput
	Nvram             DomainNvramPtrInput
	// By default is disabled, set to true for enabling it. More info [qemu-agent](https://wiki.libvirt.org/page/Qemu_guest_agent).
	QemuAgent pulumi.BoolPtrInput
	// Use `false` to turn off the instance. If not specified,
	// true is assumed and the instance, if stopped, will be started at next apply.
	Running pulumi.BoolPtrInput
	// TPM device to attach to the domain. The `tpm` object structure is documented below.
	Tpm DomainTpmPtrInput
	// The type of hypervisor to use for the domain.  Defaults to `kvm`, other values can be found [here](https://libvirt.org/formatdomain.html#id1)
	Type pulumi.StringPtrInput
	// The amount of virtual CPUs. If not specified, a single CPU
	// will be created.
	Vcpu  pulumi.IntPtrInput
	Video DomainVideoPtrInput
	Xml   DomainXmlPtrInput
}

type DomainArray []DomainInput

type DomainArrayInput interface {
	pulumi.Input

	ToDomainArrayOutput() DomainArrayOutput
	ToDomainArrayOutputWithContext(context.Context) DomainArrayOutput
}

type DomainArrayOutput struct{ *pulumi.OutputState }

type DomainBootDevice struct {
	Devs []string `pulumi:"devs"`
}

type DomainBootDeviceArgs struct {
	Devs pulumi.StringArrayInput `pulumi:"devs"`
}

type DomainBootDeviceArray []DomainBootDeviceInput

type DomainBootDeviceArrayInput interface {
	pulumi.Input

	ToDomainBootDeviceArrayOutput() DomainBootDeviceArrayOutput
	ToDomainBootDeviceArrayOutputWithContext(context.Context) DomainBootDeviceArrayOutput
}

type DomainBootDeviceArrayOutput struct{ *pulumi.OutputState }

type DomainBootDeviceInput interface {
	pulumi.Input

	ToDomainBootDeviceOutput() DomainBootDeviceOutput
	ToDomainBootDeviceOutputWithContext(context.Context) DomainBootDeviceOutput
}

type DomainBootDeviceOutput struct{ *pulumi.OutputState }

type DomainConsole struct {
	// IP address to listen on. Defaults to 127.0.0.1.
	SourceHost *string `pulumi:"sourceHost"`
	// Source path
	//
	// Additional attributes when type is "tcp":
	SourcePath *string `pulumi:"sourcePath"`
	// Port number or a service name. Defaults to a
	// random port.
	//
	// Note that you can repeat the `console` block to create more than one console.
	// This works the same way as with the `disk` blocks (see above).
	//
	// See [libvirt Domain XML Console element](https://libvirt.org/formatdomain.html#elementsConsole)
	// for more information.
	SourceService *string `pulumi:"sourceService"`
	// Target port
	TargetPort string `pulumi:"targetPort"`
	// for the first console and defaults to `serial`.
	// Subsequent `console` blocks must have a different type - usually `virtio`.
	//
	// Additional attributes when type is "pty":
	TargetType *string `pulumi:"targetType"`
	// Console device type. Valid values are "pty" and "tcp".
	Type string `pulumi:"type"`
}

type DomainConsoleArgs struct {
	// IP address to listen on. Defaults to 127.0.0.1.
	SourceHost pulumi.StringPtrInput `pulumi:"sourceHost"`
	// Source path
	//
	// Additional attributes when type is "tcp":
	SourcePath pulumi.StringPtrInput `pulumi:"sourcePath"`
	// Port number or a service name. Defaults to a
	// random port.
	//
	// Note that you can repeat the `console` block to create more than one console.
	// This works the same way as with the `disk` blocks (see above).
	//
	// See [libvirt Domain XML Console element](https://libvirt.org/formatdomain.html#elementsConsole)
	// for more information.
	SourceService pulumi.StringPtrInput `pulumi:"sourceService"`
	// Target port
	TargetPort pulumi.StringInput `pulumi:"targetPort"`
	// for the first console and defaults to `serial`.
	// Subsequent `console` blocks must have a different type - usually `virtio`.
	//
	// Additional attributes when type is "pty":
	TargetType pulumi.StringPtrInput `pulumi:"targetType"`
	// Console device type. Valid values are "pty" and "tcp".
	Type pulumi.StringInput `pulumi:"type"`
}

type DomainConsoleArray []DomainConsoleInput

type DomainConsoleArrayInput interface {
	pulumi.Input

	ToDomainConsoleArrayOutput() DomainConsoleArrayOutput
	ToDomainConsoleArrayOutputWithContext(context.Context) DomainConsoleArrayOutput
}

type DomainConsoleArrayOutput struct{ *pulumi.OutputState }

type DomainConsoleInput interface {
	pulumi.Input

	ToDomainConsoleOutput() DomainConsoleOutput
	ToDomainConsoleOutputWithContext(context.Context) DomainConsoleOutput
}

type DomainConsoleOutput struct{ *pulumi.OutputState }

type DomainCpu struct {
	Mode *string `pulumi:"mode"`
}

type DomainCpuArgs struct {
	Mode pulumi.StringPtrInput `pulumi:"mode"`
}

type DomainCpuInput interface {
	pulumi.Input

	ToDomainCpuOutput() DomainCpuOutput
	ToDomainCpuOutputWithContext(context.Context) DomainCpuOutput
}

type DomainCpuOutput struct{ *pulumi.OutputState }

type DomainCpuPtrInput interface {
	pulumi.Input

	ToDomainCpuPtrOutput() DomainCpuPtrOutput
	ToDomainCpuPtrOutputWithContext(context.Context) DomainCpuPtrOutput
}

type DomainCpuPtrOutput struct{ *pulumi.OutputState }

type DomainDisk struct {
	// The path to the host device to use as the block device for this disk.
	//
	// While `volumeId`, `url`, `file` and `blockDevice` are optional, it is intended that you use one of them.
	BlockDevice *string `pulumi:"blockDevice"`
	// The filename to use as the block device for this disk (read-only)
	File *string `pulumi:"file"`
	// Use a scsi controller for this disk.  The controller
	// model is set to `virtio-scsi`
	Scsi *bool `pulumi:"scsi"`
	// The http url to use as the block device for this disk (read-only)
	Url *string `pulumi:"url"`
	// The volume id to use for this disk.
	VolumeId *string `pulumi:"volumeId"`
	// Specify a WWN to use for the disk if the disk is using
	// a scsi controller, if not specified then a random wwn is generated for the disk
	//
	// “`go
	// package main
	//
	// import (
	// 	"github.com/pulumi/pulumi-libvirt/sdk/go/libvirt"
	// 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	// )
	//
	// func main() {
	// 	pulumi.Run(func(ctx *pulumi.Context) error {
	// 		leap, err := libvirt.NewVolume(ctx, "leap", &libvirt.VolumeArgs{
	// 			Name:   pulumi.String("leap"),
	// 			Source: pulumi.String("http://someurl/openSUSE_Leap-42.1.qcow2"),
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		mydisk, err := libvirt.NewVolume(ctx, "mydisk", &libvirt.VolumeArgs{
	// 			Name:         pulumi.String("mydisk"),
	// 			BaseVolumeId: leap.ID(),
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		_, err = libvirt.NewDomain(ctx, "domain1", &libvirt.DomainArgs{
	// 			Name: pulumi.String("domain1"),
	// 			Disks: libvirt.DomainDiskArray{
	// 				&libvirt.DomainDiskArgs{
	// 					VolumeId: mydisk.ID(),
	// 					Scsi:     pulumi.Bool(true),
	// 				},
	// 				&libvirt.DomainDiskArgs{
	// 					Url: pulumi.String("http://foo.com/install.iso"),
	// 				},
	// 				&libvirt.DomainDiskArgs{
	// 					File: pulumi.String("/absolute/path/to/disk.iso"),
	// 				},
	// 				&libvirt.DomainDiskArgs{
	// 					BlockDevice: pulumi.String("/dev/mapper/36005076802810e55400000000000145f"),
	// 				},
	// 			},
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		return nil
	// 	})
	// }
	// “`
	//
	// Also note that the `disk` block is actually a list of maps, so it is possible to
	// declare several of them by using either the literal list and map syntax as in
	// the following examples:
	Wwn *string `pulumi:"wwn"`
}

type DomainDiskArgs struct {
	// The path to the host device to use as the block device for this disk.
	//
	// While `volumeId`, `url`, `file` and `blockDevice` are optional, it is intended that you use one of them.
	BlockDevice pulumi.StringPtrInput `pulumi:"blockDevice"`
	// The filename to use as the block device for this disk (read-only)
	File pulumi.StringPtrInput `pulumi:"file"`
	// Use a scsi controller for this disk.  The controller
	// model is set to `virtio-scsi`
	Scsi pulumi.BoolPtrInput `pulumi:"scsi"`
	// The http url to use as the block device for this disk (read-only)
	Url pulumi.StringPtrInput `pulumi:"url"`
	// The volume id to use for this disk.
	VolumeId pulumi.StringPtrInput `pulumi:"volumeId"`
	// Specify a WWN to use for the disk if the disk is using
	// a scsi controller, if not specified then a random wwn is generated for the disk
	//
	// “`go
	// package main
	//
	// import (
	// 	"github.com/pulumi/pulumi-libvirt/sdk/go/libvirt"
	// 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	// )
	//
	// func main() {
	// 	pulumi.Run(func(ctx *pulumi.Context) error {
	// 		leap, err := libvirt.NewVolume(ctx, "leap", &libvirt.VolumeArgs{
	// 			Name:   pulumi.String("leap"),
	// 			Source: pulumi.String("http://someurl/openSUSE_Leap-42.1.qcow2"),
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		mydisk, err := libvirt.NewVolume(ctx, "mydisk", &libvirt.VolumeArgs{
	// 			Name:         pulumi.String("mydisk"),
	// 			BaseVolumeId: leap.ID(),
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		_, err = libvirt.NewDomain(ctx, "domain1", &libvirt.DomainArgs{
	// 			Name: pulumi.String("domain1"),
	// 			Disks: libvirt.DomainDiskArray{
	// 				&libvirt.DomainDiskArgs{
	// 					VolumeId: mydisk.ID(),
	// 					Scsi:     pulumi.Bool(true),
	// 				},
	// 				&libvirt.DomainDiskArgs{
	// 					Url: pulumi.String("http://foo.com/install.iso"),
	// 				},
	// 				&libvirt.DomainDiskArgs{
	// 					File: pulumi.String("/absolute/path/to/disk.iso"),
	// 				},
	// 				&libvirt.DomainDiskArgs{
	// 					BlockDevice: pulumi.String("/dev/mapper/36005076802810e55400000000000145f"),
	// 				},
	// 			},
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		return nil
	// 	})
	// }
	// “`
	//
	// Also note that the `disk` block is actually a list of maps, so it is possible to
	// declare several of them by using either the literal list and map syntax as in
	// the following examples:
	Wwn pulumi.StringPtrInput `pulumi:"wwn"`
}

type DomainDiskArray []DomainDiskInput

type DomainDiskArrayInput interface {
	pulumi.Input

	ToDomainDiskArrayOutput() DomainDiskArrayOutput
	ToDomainDiskArrayOutputWithContext(context.Context) DomainDiskArrayOutput
}

type DomainDiskArrayOutput struct{ *pulumi.OutputState }

type DomainDiskInput interface {
	pulumi.Input

	ToDomainDiskOutput() DomainDiskOutput
	ToDomainDiskOutputWithContext(context.Context) DomainDiskOutput
}

type DomainDiskOutput struct{ *pulumi.OutputState }

type DomainFilesystem struct {
	// specifies the security mode for accessing the source. By default
	// the `mapped` mode is chosen.
	Accessmode *string `pulumi:"accessmode"`
	// enables exporting filesystem as a readonly mount for guest, by
	// default read-only access is given.
	//
	// Example:
	Readonly *bool `pulumi:"readonly"`
	// the directory of the host to be shared with the guest.
	Source string `pulumi:"source"`
	// an arbitrary string tag that is exported to the guest as a hint for
	// where to mount the source.
	Target string `pulumi:"target"`
}

type DomainFilesystemArgs struct {
	// specifies the security mode for accessing the source. By default
	// the `mapped` mode is chosen.
	Accessmode pulumi.StringPtrInput `pulumi:"accessmode"`
	// enables exporting filesystem as a readonly mount for guest, by
	// default read-only access is given.
	//
	// Example:
	Readonly pulumi.BoolPtrInput `pulumi:"readonly"`
	// the directory of the host to be shared with the guest.
	Source pulumi.StringInput `pulumi:"source"`
	// an arbitrary string tag that is exported to the guest as a hint for
	// where to mount the source.
	Target pulumi.StringInput `pulumi:"target"`
}

type DomainFilesystemArray []DomainFilesystemInput

type DomainFilesystemArrayInput interface {
	pulumi.Input

	ToDomainFilesystemArrayOutput() DomainFilesystemArrayOutput
	ToDomainFilesystemArrayOutputWithContext(context.Context) DomainFilesystemArrayOutput
}

type DomainFilesystemArrayOutput struct{ *pulumi.OutputState }

type DomainFilesystemInput interface {
	pulumi.Input

	ToDomainFilesystemOutput() DomainFilesystemOutput
	ToDomainFilesystemOutputWithContext(context.Context) DomainFilesystemOutput
}

type DomainFilesystemOutput struct{ *pulumi.OutputState }

type DomainGraphics struct {
	// defaults to "yes"
	Autoport *bool `pulumi:"autoport"`
	// IP Address where the VNC listener should be started if
	// `listenType` is set to `address`. Defaults to 127.0.0.1
	ListenAddress *string `pulumi:"listenAddress"`
	// "listen type", defaults to "none"
	ListenType *string `pulumi:"listenType"`
	// the type of graphics emulation (default is "spice")
	Type *string `pulumi:"type"`
	// Port to listen on for VNC WebSocket functionality (-1 meaning auto-allocation)
	//
	// On occasion we have found it necessary to set a `type` of `vnc` and a
	// `listenType` of `address` with certain builds of QEMU.
	//
	// With `listenAddress` it is possible to specify a listener address for the virtual
	// machines VNC server. Usually this is an IP of the host system.
	//
	// The `graphics` block will look as follows:
	Websocket *int `pulumi:"websocket"`
}

type DomainGraphicsArgs struct {
	// defaults to "yes"
	Autoport pulumi.BoolPtrInput `pulumi:"autoport"`
	// IP Address where the VNC listener should be started if
	// `listenType` is set to `address`. Defaults to 127.0.0.1
	ListenAddress pulumi.StringPtrInput `pulumi:"listenAddress"`
	// "listen type", defaults to "none"
	ListenType pulumi.StringPtrInput `pulumi:"listenType"`
	// the type of graphics emulation (default is "spice")
	Type pulumi.StringPtrInput `pulumi:"type"`
	// Port to listen on for VNC WebSocket functionality (-1 meaning auto-allocation)
	//
	// On occasion we have found it necessary to set a `type` of `vnc` and a
	// `listenType` of `address` with certain builds of QEMU.
	//
	// With `listenAddress` it is possible to specify a listener address for the virtual
	// machines VNC server. Usually this is an IP of the host system.
	//
	// The `graphics` block will look as follows:
	Websocket pulumi.IntPtrInput `pulumi:"websocket"`
}

type DomainGraphicsInput interface {
	pulumi.Input

	ToDomainGraphicsOutput() DomainGraphicsOutput
	ToDomainGraphicsOutputWithContext(context.Context) DomainGraphicsOutput
}

type DomainGraphicsOutput struct{ *pulumi.OutputState }

type DomainGraphicsPtrInput interface {
	pulumi.Input

	ToDomainGraphicsPtrOutput() DomainGraphicsPtrOutput
	ToDomainGraphicsPtrOutputWithContext(context.Context) DomainGraphicsPtrOutput
}

type DomainGraphicsPtrOutput struct{ *pulumi.OutputState }

type DomainInput interface {
	pulumi.Input

	ToDomainOutput() DomainOutput
	ToDomainOutputWithContext(ctx context.Context) DomainOutput
}

type DomainMap map[string]DomainInput

type DomainMapInput interface {
	pulumi.Input

	ToDomainMapOutput() DomainMapOutput
	ToDomainMapOutputWithContext(context.Context) DomainMapOutput
}

type DomainMapOutput struct{ *pulumi.OutputState }

type DomainNetworkInterface struct {
	// An IP address for this domain in this network.
	Addresses []string `pulumi:"addresses"`
	// Provides a bridge from the VM directly to the LAN. This assumes
	// there is a bridge device on the host which has one or more of the hosts
	// physical NICs enslaved. The guest VM will have an associated _tun_ device
	// created and enslaved to the bridge. The IP range / network configuration is
	// whatever is used on the LAN. This provides the guest VM full incoming &
	// outgoing net access just like a physical machine.
	Bridge *string `pulumi:"bridge"`
	// A hostname that will be assigned to this domain
	// resource in this network.
	Hostname *string `pulumi:"hostname"`
	// The specific MAC address to use for this interface.
	Mac *string `pulumi:"mac"`
	// Packets whose destination is on the same host as where they
	// originate from are directly delivered to the target macvtap device. Both
	// origin and destination devices need to be in bridge mode for direct delivery.
	// If either one of them is in vepa mode, a VEPA capable bridge is required.
	Macvtap     *string `pulumi:"macvtap"`
	NetworkId   *string `pulumi:"networkId"`
	NetworkName *string `pulumi:"networkName"`
	// This feature attaches a virtual function of a SRIOV capable
	// NIC directly to a VM without losing the migration capability. All packets are
	// sent to the VF/IF of the configured network device. Depending on the
	// capabilities of the device additional prerequisites or limitations may apply;
	// for example, on Linux this requires kernel 2.6.38 or newer.
	//
	// Example of a `macvtap` interface:
	Passthrough *string `pulumi:"passthrough"`
	// All VMs' packets are sent to the external bridge. Packets whose
	// destination is a VM on the same host as where the packet originates from are
	// sent back to the host by the VEPA capable bridge (today's bridges are
	// typically not VEPA capable).
	Vepa *string `pulumi:"vepa"`
	// When creating the domain resource, wait until the
	// network interface gets a DHCP lease from libvirt, so that the computed IP
	// addresses will be available when the domain is up and the plan applied.
	//
	// When connecting to a LAN, users can specify a target device with:
	WaitForLease *bool `pulumi:"waitForLease"`
}

type DomainNetworkInterfaceArgs struct {
	// An IP address for this domain in this network.
	Addresses pulumi.StringArrayInput `pulumi:"addresses"`
	// Provides a bridge from the VM directly to the LAN. This assumes
	// there is a bridge device on the host which has one or more of the hosts
	// physical NICs enslaved. The guest VM will have an associated _tun_ device
	// created and enslaved to the bridge. The IP range / network configuration is
	// whatever is used on the LAN. This provides the guest VM full incoming &
	// outgoing net access just like a physical machine.
	Bridge pulumi.StringPtrInput `pulumi:"bridge"`
	// A hostname that will be assigned to this domain
	// resource in this network.
	Hostname pulumi.StringPtrInput `pulumi:"hostname"`
	// The specific MAC address to use for this interface.
	Mac pulumi.StringPtrInput `pulumi:"mac"`
	// Packets whose destination is on the same host as where they
	// originate from are directly delivered to the target macvtap device. Both
	// origin and destination devices need to be in bridge mode for direct delivery.
	// If either one of them is in vepa mode, a VEPA capable bridge is required.
	Macvtap     pulumi.StringPtrInput `pulumi:"macvtap"`
	NetworkId   pulumi.StringPtrInput `pulumi:"networkId"`
	NetworkName pulumi.StringPtrInput `pulumi:"networkName"`
	// This feature attaches a virtual function of a SRIOV capable
	// NIC directly to a VM without losing the migration capability. All packets are
	// sent to the VF/IF of the configured network device. Depending on the
	// capabilities of the device additional prerequisites or limitations may apply;
	// for example, on Linux this requires kernel 2.6.38 or newer.
	//
	// Example of a `macvtap` interface:
	Passthrough pulumi.StringPtrInput `pulumi:"passthrough"`
	// All VMs' packets are sent to the external bridge. Packets whose
	// destination is a VM on the same host as where the packet originates from are
	// sent back to the host by the VEPA capable bridge (today's bridges are
	// typically not VEPA capable).
	Vepa pulumi.StringPtrInput `pulumi:"vepa"`
	// When creating the domain resource, wait until the
	// network interface gets a DHCP lease from libvirt, so that the computed IP
	// addresses will be available when the domain is up and the plan applied.
	//
	// When connecting to a LAN, users can specify a target device with:
	WaitForLease pulumi.BoolPtrInput `pulumi:"waitForLease"`
}

type DomainNetworkInterfaceArray []DomainNetworkInterfaceInput

type DomainNetworkInterfaceArrayInput interface {
	pulumi.Input

	ToDomainNetworkInterfaceArrayOutput() DomainNetworkInterfaceArrayOutput
	ToDomainNetworkInterfaceArrayOutputWithContext(context.Context) DomainNetworkInterfaceArrayOutput
}

type DomainNetworkInterfaceArrayOutput struct{ *pulumi.OutputState }

type DomainNetworkInterfaceInput interface {
	pulumi.Input

	ToDomainNetworkInterfaceOutput() DomainNetworkInterfaceOutput
	ToDomainNetworkInterfaceOutputWithContext(context.Context) DomainNetworkInterfaceOutput
}

type DomainNetworkInterfaceOutput struct{ *pulumi.OutputState }

type DomainNvram struct {
	File *string `pulumi:"file"`
	// path to the file used to override variables from the master NVRAM
	// store.
	//
	// So you should typically use the firmware as this,
	Template *string `pulumi:"template"`
}

type DomainNvramArgs struct {
	File pulumi.StringPtrInput `pulumi:"file"`
	// path to the file used to override variables from the master NVRAM
	// store.
	//
	// So you should typically use the firmware as this,
	Template pulumi.StringPtrInput `pulumi:"template"`
}

type DomainNvramInput interface {
	pulumi.Input

	ToDomainNvramOutput() DomainNvramOutput
	ToDomainNvramOutputWithContext(context.Context) DomainNvramOutput
}

type DomainNvramOutput struct{ *pulumi.OutputState }

type DomainNvramPtrInput interface {
	pulumi.Input

	ToDomainNvramPtrOutput() DomainNvramPtrOutput
	ToDomainNvramPtrOutputWithContext(context.Context) DomainNvramPtrOutput
}

type DomainNvramPtrOutput struct{ *pulumi.OutputState }

type DomainOutput struct{ *pulumi.OutputState }

type DomainState struct {
	// The architecture for the VM (probably x8664 or i686),
	// you normally won't need to set this unless you are building a special VM
	Arch pulumi.StringPtrInput
	// Set to `true` to start the domain on host boot up.
	// If not specified `false` is assumed.
	Autostart pulumi.BoolPtrInput
	// A list of devices (dev) which defines boot order. Example
	// below.
	BootDevices DomainBootDeviceArrayInput
	// The `CloudInitDisk` disk that has to be used by
	// the domain. This is going to be attached as a CDROM ISO. Changing the
	// cloud-init won't cause the domain to be recreated, however the change will
	// have effect on the next reboot.
	Cloudinit pulumi.StringPtrInput
	Cmdlines  pulumi.StringMapArrayInput
	Consoles  DomainConsoleArrayInput
	// The
	// [Ignition](https://www.terraform.io/docs/providers/libvirt/r/coreos_ignition.html) resource
	// that is to be used by the CoreOS domain.
	CoreosIgnition pulumi.StringPtrInput
	// Configures CPU mode. See below for more
	// details.
	Cpu DomainCpuPtrInput
	// The description for domain.
	// Changing this forces a new resource to be created.
	// This data is not used by libvirt in any way, it can contain any information the user wants.
	Description pulumi.StringPtrInput
	// An array of one or more disks to attach to the domain. The
	// `disk` object structure is documented below.
	Disks DomainDiskArrayInput
	// The path of the emulator to use
	Emulator pulumi.StringPtrInput
	// An array of one or more host filesystems to attach to
	// the domain. The `filesystem` object structure is documented
	// below.
	Filesystems DomainFilesystemArrayInput
	Firmware    pulumi.StringPtrInput
	// The name of the firmware config path where ignition file is stored: default is `opt/com.coreos/config`. If you are using [Flatcar Linux](https://docs.flatcar-linux.org/os/booting-with-libvirt/#creating-the-domain-xml), the value is `opt/org.flatcar-linux/config`.
	FwCfgName pulumi.StringPtrInput
	Graphics  DomainGraphicsPtrInput
	Initrd    pulumi.StringPtrInput
	Kernel    pulumi.StringPtrInput
	// The machine type,
	// you normally won't need to set this unless you are running on a platform that
	// defaults to the wrong machine type for your template
	Machine pulumi.StringPtrInput
	// The amount of memory in MiB. If not specified the domain
	// will be created with 512 MiB of memory be used.
	Memory   pulumi.IntPtrInput
	Metadata pulumi.StringPtrInput
	// A unique name for the resource, required by libvirt.
	// Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// An array of one or more network interfaces to
	// attach to the domain. The `networkInterface` object structure is documented
	// below.
	NetworkInterfaces DomainNetworkInterfaceArrayInput
	Nvram             DomainNvramPtrInput
	// By default is disabled, set to true for enabling it. More info [qemu-agent](https://wiki.libvirt.org/page/Qemu_guest_agent).
	QemuAgent pulumi.BoolPtrInput
	// Use `false` to turn off the instance. If not specified,
	// true is assumed and the instance, if stopped, will be started at next apply.
	Running pulumi.BoolPtrInput
	// TPM device to attach to the domain. The `tpm` object structure is documented below.
	Tpm DomainTpmPtrInput
	// The type of hypervisor to use for the domain.  Defaults to `kvm`, other values can be found [here](https://libvirt.org/formatdomain.html#id1)
	Type pulumi.StringPtrInput
	// The amount of virtual CPUs. If not specified, a single CPU
	// will be created.
	Vcpu  pulumi.IntPtrInput
	Video DomainVideoPtrInput
	Xml   DomainXmlPtrInput
}

type DomainTpm struct {
	// Path to TPM device on the host, ex: `/dev/tpm0`
	//
	// Additional attributes when `backendType` is "emulator":
	BackendDevicePath *string `pulumi:"backendDevicePath"`
	// [Secret object](https://libvirt.org/formatsecret.html) for encrypting the TPM state
	BackendEncryptionSecret *string `pulumi:"backendEncryptionSecret"`
	// Keep the TPM state when a transient domain is powered off or undefined
	BackendPersistentState *bool `pulumi:"backendPersistentState"`
	// TPM backend, either `passthrough` or `emulator` (default: `emulator`)
	//
	// Additional attributes when `backendType` is "passthrough":
	BackendType *string `pulumi:"backendType"`
	// TPM version
	BackendVersion *string `pulumi:"backendVersion"`
	// TPM model provided to the guest
	Model *string `pulumi:"model"`
}