# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import copy
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from . import _utilities
from . import outputs

__all__ = [
    'DomainBootDevice',
    'DomainConsole',
    'DomainCpu',
    'DomainDisk',
    'DomainFilesystem',
    'DomainGraphics',
    'DomainNetworkInterface',
    'DomainNvram',
    'DomainTpm',
    'DomainVideo',
    'DomainXml',
    'NetworkDhcp',
    'NetworkDns',
    'NetworkDnsForwarder',
    'NetworkDnsHost',
    'NetworkDnsSrv',
    'NetworkDnsmasqOptions',
    'NetworkDnsmasqOptionsOption',
    'NetworkRoute',
    'NetworkXml',
    'PoolSource',
    'PoolSourceDevice',
    'PoolTarget',
    'PoolXml',
    'VolumeXml',
    'GetNodeDeviceInfoCapabilityResult',
    'GetNodeDeviceInfoCapabilityIommuGroupResult',
    'GetNodeDeviceInfoDevnodeResult',
]

@pulumi.output_type
class DomainBootDevice(dict):
    def __init__(__self__, *,
                 devs: Optional[Sequence[str]] = None):
        if devs is not None:
            pulumi.set(__self__, "devs", devs)

    @property
    @pulumi.getter
    def devs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "devs")


@pulumi.output_type
class DomainConsole(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetPort":
            suggest = "target_port"
        elif key == "sourceHost":
            suggest = "source_host"
        elif key == "sourcePath":
            suggest = "source_path"
        elif key == "sourceService":
            suggest = "source_service"
        elif key == "targetType":
            suggest = "target_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DomainConsole. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DomainConsole.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DomainConsole.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 target_port: str,
                 type: str,
                 source_host: Optional[str] = None,
                 source_path: Optional[str] = None,
                 source_service: Optional[str] = None,
                 target_type: Optional[str] = None):
        """
        :param str target_port: Target port
        :param str type: Console device type. Valid values are "pty" and "tcp".
        :param str source_host: IP address to listen on. Defaults to 127.0.0.1.
        :param str source_path: Source path
               
               Additional attributes when type is "tcp":
        :param str source_service: 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.
        :param str target_type: for the first console and defaults to `serial`.
               Subsequent `console` blocks must have a different type - usually `virtio`.
               
               Additional attributes when type is "pty":
        """
        pulumi.set(__self__, "target_port", target_port)
        pulumi.set(__self__, "type", type)
        if source_host is not None:
            pulumi.set(__self__, "source_host", source_host)
        if source_path is not None:
            pulumi.set(__self__, "source_path", source_path)
        if source_service is not None:
            pulumi.set(__self__, "source_service", source_service)
        if target_type is not None:
            pulumi.set(__self__, "target_type", target_type)

    @property
    @pulumi.getter(name="targetPort")
    def target_port(self) -> str:
        """
        Target port
        """
        return pulumi.get(self, "target_port")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Console device type. Valid values are "pty" and "tcp".
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="sourceHost")
    def source_host(self) -> Optional[str]:
        """
        IP address to listen on. Defaults to 127.0.0.1.
        """
        return pulumi.get(self, "source_host")

    @property
    @pulumi.getter(name="sourcePath")
    def source_path(self) -> Optional[str]:
        """
        Source path

        Additional attributes when type is "tcp":
        """
        return pulumi.get(self, "source_path")

    @property
    @pulumi.getter(name="sourceService")
    def source_service(self) -> Optional[str]:
        """
        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.
        """
        return pulumi.get(self, "source_service")

    @property
    @pulumi.getter(name="targetType")
    def target_type(self) -> Optional[str]:
        """
        for the first console and defaults to `serial`.
        Subsequent `console` blocks must have a different type - usually `virtio`.

        Additional attributes when type is "pty":
        """
        return pulumi.get(self, "target_type")


@pulumi.output_type
class DomainCpu(dict):
    def __init__(__self__, *,
                 mode: Optional[str] = None):
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def mode(self) -> Optional[str]:
        return pulumi.get(self, "mode")


@pulumi.output_type
class DomainDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "blockDevice":
            suggest = "block_device"
        elif key == "volumeId":
            suggest = "volume_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DomainDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DomainDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DomainDisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 block_device: Optional[str] = None,
                 file: Optional[str] = None,
                 scsi: Optional[bool] = None,
                 url: Optional[str] = None,
                 volume_id: Optional[str] = None,
                 wwn: Optional[str] = None):
        """
        :param str block_device: The path to the host device to use as the block device for this disk. 
               
               While `volume_id`, `url`, `file` and `block_device` are optional, it is intended that you use one of them.
        :param str file: The filename to use as the block device for this disk (read-only)
        :param bool scsi: Use a scsi controller for this disk.  The controller
               model is set to `virtio-scsi`
        :param str url: The http url to use as the block device for this disk (read-only)
        :param str volume_id: The volume id to use for this disk.
        :param str wwn: 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
               
               
               ```python
               import pulumi
               import pulumi_libvirt as libvirt
               
               leap = libvirt.Volume("leap",
                   name="leap",
                   source="http://someurl/openSUSE_Leap-42.1.qcow2")
               mydisk = libvirt.Volume("mydisk",
                   name="mydisk",
                   base_volume_id=leap.id)
               domain1 = libvirt.Domain("domain1",
                   name="domain1",
                   disks=[
                       {
                           "volume_id": mydisk.id,
                           "scsi": True,
                       },
                       {
                           "url": "http://foo.com/install.iso",
                       },
                       {
                           "file": "/absolute/path/to/disk.iso",
                       },
                       {
                           "block_device": "/dev/mapper/36005076802810e55400000000000145f",
                       },
                   ])
               ```
               
               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:
        """
        if block_device is not None:
            pulumi.set(__self__, "block_device", block_device)
        if file is not None:
            pulumi.set(__self__, "file", file)
        if scsi is not None:
            pulumi.set(__self__, "scsi", scsi)
        if url is not None:
            pulumi.set(__self__, "url", url)
        if volume_id is not None:
            pulumi.set(__self__, "volume_id", volume_id)
        if wwn is not None:
            pulumi.set(__self__, "wwn", wwn)

    @property
    @pulumi.getter(name="blockDevice")
    def block_device(self) -> Optional[str]:
        """
        The path to the host device to use as the block device for this disk. 

        While `volume_id`, `url`, `file` and `block_device` are optional, it is intended that you use one of them.
        """
        return pulumi.get(self, "block_device")

    @property
    @pulumi.getter
    def file(self) -> Optional[str]:
        """
        The filename to use as the block device for this disk (read-only)
        """
        return pulumi.get(self, "file")

    @property
    @pulumi.getter
    def scsi(self) -> Optional[bool]:
        """
        Use a scsi controller for this disk.  The controller
        model is set to `virtio-scsi`
        """
        return pulumi.get(self, "scsi")

    @property
    @pulumi.getter
    def url(self) -> Optional[str]:
        """
        The http url to use as the block device for this disk (read-only)
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="volumeId")
    def volume_id(self) -> Optional[str]:
        """
        The volume id to use for this disk.
        """
        return pulumi.get(self, "volume_id")

    @property
    @pulumi.getter
    def wwn(self) -> Optional[str]:
        """
        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


        ```python
        import pulumi
        import pulumi_libvirt as libvirt

        leap = libvirt.Volume("leap",
            name="leap",
            source="http://someurl/openSUSE_Leap-42.1.qcow2")
        mydisk = libvirt.Volume("mydisk",
            name="mydisk",
            base_volume_id=leap.id)
        domain1 = libvirt.Domain("domain1",
            name="domain1",
            disks=[
                {
                    "volume_id": mydisk.id,
                    "scsi": True,
                },
                {
                    "url": "http://foo.com/install.iso",
                },
                {
                    "file": "/absolute/path/to/disk.iso",
                },
                {
                    "block_device": "/dev/mapper/36005076802810e55400000000000145f",
                },
            ])
        ```

        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:
        """
        return pulumi.get(self, "wwn")


@pulumi.output_type
class DomainFilesystem(dict):
    def __init__(__self__, *,
                 source: str,
                 target: str,
                 accessmode: Optional[str] = None,
                 readonly: Optional[bool] = None):
        """
        :param str source: the directory of the host to be shared with the guest.
        :param str target: an arbitrary string tag that is exported to the guest as a hint for
               where to mount the source.
        :param str accessmode: specifies the security mode for accessing the source. By default
               the `mapped` mode is chosen.
        :param bool readonly: enables exporting filesystem as a readonly mount for guest, by
               default read-only access is given.
               
               Example:
        """
        pulumi.set(__self__, "source", source)
        pulumi.set(__self__, "target", target)
        if accessmode is not None:
            pulumi.set(__self__, "accessmode", accessmode)
        if readonly is not None:
            pulumi.set(__self__, "readonly", readonly)

    @property
    @pulumi.getter
    def source(self) -> str:
        """
        the directory of the host to be shared with the guest.
        """
        return pulumi.get(self, "source")

    @property
    @pulumi.getter
    def target(self) -> str:
        """
        an arbitrary string tag that is exported to the guest as a hint for
        where to mount the source.
        """
        return pulumi.get(self, "target")

    @property
    @pulumi.getter
    def accessmode(self) -> Optional[str]:
        """
        specifies the security mode for accessing the source. By default
        the `mapped` mode is chosen.
        """
        return pulumi.get(self, "accessmode")

    @property
    @pulumi.getter
    def readonly(self) -> Optional[bool]:
        """
        enables exporting filesystem as a readonly mount for guest, by
        default read-only access is given.

        Example:
        """
        return pulumi.get(self, "readonly")


@pulumi.output_type
class DomainGraphics(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "listenAddress":
            suggest = "listen_address"
        elif key == "listenType":
            suggest = "listen_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DomainGraphics. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DomainGraphics.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DomainGraphics.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 autoport: Optional[bool] = None,
                 listen_address: Optional[str] = None,
                 listen_type: Optional[str] = None,
                 type: Optional[str] = None,
                 websocket: Optional[int] = None):
        """
        :param bool autoport: defaults to "yes"
        :param str listen_address: IP Address where the VNC listener should be started if
               `listen_type` is set to `address`. Defaults to 127.0.0.1
        :param str listen_type: "listen type", defaults to "none"
        :param str type: the type of graphics emulation (default is "spice")
        :param int websocket: 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
               `listen_type` of `address` with certain builds of QEMU.
               
               With `listen_address` 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:
        """
        if autoport is not None:
            pulumi.set(__self__, "autoport", autoport)
        if listen_address is not None:
            pulumi.set(__self__, "listen_address", listen_address)
        if listen_type is not None:
            pulumi.set(__self__, "listen_type", listen_type)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if websocket is not None:
            pulumi.set(__self__, "websocket", websocket)

    @property
    @pulumi.getter
    def autoport(self) -> Optional[bool]:
        """
        defaults to "yes"
        """
        return pulumi.get(self, "autoport")

    @property
    @pulumi.getter(name="listenAddress")
    def listen_address(self) -> Optional[str]:
        """
        IP Address where the VNC listener should be started if
        `listen_type` is set to `address`. Defaults to 127.0.0.1
        """
        return pulumi.get(self, "listen_address")

    @property
    @pulumi.getter(name="listenType")
    def listen_type(self) -> Optional[str]:
        """
        "listen type", defaults to "none"
        """
        return pulumi.get(self, "listen_type")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        the type of graphics emulation (default is "spice")
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def websocket(self) -> Optional[int]:
        """
        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
        `listen_type` of `address` with certain builds of QEMU.

        With `listen_address` 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:
        """
        return pulumi.get(self, "websocket")


@pulumi.output_type
class DomainNetworkInterface(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "networkId":
            suggest = "network_id"
        elif key == "networkName":
            suggest = "network_name"
        elif key == "waitForLease":
            suggest = "wait_for_lease"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DomainNetworkInterface. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DomainNetworkInterface.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DomainNetworkInterface.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 addresses: Optional[Sequence[str]] = None,
                 bridge: Optional[str] = None,
                 hostname: Optional[str] = None,
                 mac: Optional[str] = None,
                 macvtap: Optional[str] = None,
                 network_id: Optional[str] = None,
                 network_name: Optional[str] = None,
                 passthrough: Optional[str] = None,
                 vepa: Optional[str] = None,
                 wait_for_lease: Optional[bool] = None):
        """
        :param Sequence[str] addresses: An IP address for this domain in this network.
        :param str bridge: 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.
        :param str hostname: A hostname that will be assigned to this domain
               resource in this network.
        :param str mac: The specific MAC address to use for this interface.
        :param str macvtap: 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.
        :param str passthrough: 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:
        :param str vepa: 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).
        :param bool wait_for_lease: 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:
        """
        if addresses is not None:
            pulumi.set(__self__, "addresses", addresses)
        if bridge is not None:
            pulumi.set(__self__, "bridge", bridge)
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if mac is not None:
            pulumi.set(__self__, "mac", mac)
        if macvtap is not None:
            pulumi.set(__self__, "macvtap", macvtap)
        if network_id is not None:
            pulumi.set(__self__, "network_id", network_id)
        if network_name is not None:
            pulumi.set(__self__, "network_name", network_name)
        if passthrough is not None:
            pulumi.set(__self__, "passthrough", passthrough)
        if vepa is not None:
            pulumi.set(__self__, "vepa", vepa)
        if wait_for_lease is not None:
            pulumi.set(__self__, "wait_for_lease", wait_for_lease)

    @property
    @pulumi.getter
    def addresses(self) -> Optional[Sequence[str]]:
        """
        An IP address for this domain in this network.
        """
        return pulumi.get(self, "addresses")

    @property
    @pulumi.getter
    def bridge(self) -> Optional[str]:
        """
        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.
        """
        return pulumi.get(self, "bridge")

    @property
    @pulumi.getter
    def hostname(self) -> Optional[str]:
        """
        A hostname that will be assigned to this domain
        resource in this network.
        """
        return pulumi.get(self, "hostname")

    @property
    @pulumi.getter
    def mac(self) -> Optional[str]:
        """
        The specific MAC address to use for this interface.
        """
        return pulumi.get(self, "mac")

    @property
    @pulumi.getter
    def macvtap(self) -> Optional[str]:
        """
        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.
        """
        return pulumi.get(self, "macvtap")

    @property
    @pulumi.getter(name="networkId")
    def network_id(self) -> Optional[str]:
        return pulumi.get(self, "network_id")

    @property
    @pulumi.getter(name="networkName")
    def network_name(self) -> Optional[str]:
        return pulumi.get(self, "network_name")

    @property
    @pulumi.getter
    def passthrough(self) -> Optional[str]:
        """
        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:
        """
        return pulumi.get(self, "passthrough")

    @property
    @pulumi.getter
    def vepa(self) -> Optional[str]:
        """
        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).
        """
        return pulumi.get(self, "vepa")

    @property
    @pulumi.getter(name="waitForLease")
    def wait_for_lease(self) -> Optional[bool]:
        """
        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:
        """
        return pulumi.get(self, "wait_for_lease")


@pulumi.output_type
class DomainNvram(dict):
    def __init__(__self__, *,
                 file: Optional[str] = None,
                 template: Optional[str] = None):
        """
        :param str template: path to the file used to override variables from the master NVRAM
               store.
               
               So you should typically use the firmware as this,
        """
        if file is not None:
            pulumi.set(__self__, "file", file)
        if template is not None:
            pulumi.set(__self__, "template", template)

    @property
    @pulumi.getter
    def file(self) -> Optional[str]:
        return pulumi.get(self, "file")

    @property
    @pulumi.getter
    def template(self) -> Optional[str]:
        """
        path to the file used to override variables from the master NVRAM
        store.

        So you should typically use the firmware as this,
        """
        return pulumi.get(self, "template")


@pulumi.output_type
class DomainTpm(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backendDevicePath":
            suggest = "backend_device_path"
        elif key == "backendEncryptionSecret":
            suggest = "backend_encryption_secret"
        elif key == "backendPersistentState":
            suggest = "backend_persistent_state"
        elif key == "backendType":
            suggest = "backend_type"
        elif key == "backendVersion":
            suggest = "backend_version"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DomainTpm. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DomainTpm.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DomainTpm.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 backend_device_path: Optional[str] = None,
                 backend_encryption_secret: Optional[str] = None,
                 backend_persistent_state: Optional[bool] = None,
                 backend_type: Optional[str] = None,
                 backend_version: Optional[str] = None,
                 model: Optional[str] = None):
        """
        :param str backend_device_path: Path to TPM device on the host, ex: `/dev/tpm0`
               
               Additional attributes when `backend_type` is "emulator":
        :param str backend_encryption_secret: [Secret object](https://libvirt.org/formatsecret.html) for encrypting the TPM state
        :param bool backend_persistent_state: Keep the TPM state when a transient domain is powered off or undefined
        :param str backend_type: TPM backend, either `passthrough` or `emulator` (default: `emulator`)
               
               Additional attributes when `backend_type` is "passthrough":
        :param str backend_version: TPM version
        :param str model: TPM model provided to the guest
        """
        if backend_device_path is not None:
            pulumi.set(__self__, "backend_device_path", backend_device_path)
        if backend_encryption_secret is not None:
            pulumi.set(__self__, "backend_encryption_secret", backend_encryption_secret)
        if backend_persistent_state is not None:
            pulumi.set(__self__, "backend_persistent_state", backend_persistent_state)
        if backend_type is not None:
            pulumi.set(__self__, "backend_type", backend_type)
        if backend_version is not None:
            pulumi.set(__self__, "backend_version", backend_version)
        if model is not None:
            pulumi.set(__self__, "model", model)

    @property
    @pulumi.getter(name="backendDevicePath")
    def backend_device_path(self) -> Optional[str]:
        """
        Path to TPM device on the host, ex: `/dev/tpm0`

        Additional attributes when `backend_type` is "emulator":
        """
        return pulumi.get(self, "backend_device_path")

    @property
    @pulumi.getter(name="backendEncryptionSecret")
    def backend_encryption_secret(self) -> Optional[str]:
        """
        [Secret object](https://libvirt.org/formatsecret.html) for encrypting the TPM state
        """
        return pulumi.get(self, "backend_encryption_secret")

    @property
    @pulumi.getter(name="backendPersistentState")
    def backend_persistent_state(self) -> Optional[bool]:
        """
        Keep the TPM state when a transient domain is powered off or undefined
        """
        return pulumi.get(self, "backend_persistent_state")

    @property
    @pulumi.getter(name="backendType")
    def backend_type(self) -> Optional[str]:
        """
        TPM backend, either `passthrough` or `emulator` (default: `emulator`)

        Additional attributes when `backend_type` is "passthrough":
        """
        return pulumi.get(self, "backend_type")

    @property
    @pulumi.getter(name="backendVersion")
    def backend_version(self) -> Optional[str]:
        """
        TPM version
        """
        return pulumi.get(self, "backend_version")

    @property
    @pulumi.getter
    def model(self) -> Optional[str]:
        """
        TPM model provided to the guest
        """
        return pulumi.get(self, "model")


@pulumi.output_type
class DomainVideo(dict):
    def __init__(__self__, *,
                 type: Optional[str] = None):
        """
        :param str type: The type of hypervisor to use for the domain.  Defaults to `kvm`, other values can be found [here](https://libvirt.org/formatdomain.html#id1)
        """
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        The type of hypervisor to use for the domain.  Defaults to `kvm`, other values can be found [here](https://libvirt.org/formatdomain.html#id1)
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class DomainXml(dict):
    def __init__(__self__, *,
                 xslt: Optional[str] = None):
        if xslt is not None:
            pulumi.set(__self__, "xslt", xslt)

    @property
    @pulumi.getter
    def xslt(self) -> Optional[str]:
        return pulumi.get(self, "xslt")


@pulumi.output_type
class NetworkDhcp(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None):
        """
        :param bool enabled: when false, disable the DHCP server
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        when false, disable the DHCP server
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class NetworkDns(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "localOnly":
            suggest = "local_only"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkDns. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkDns.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkDns.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 forwarders: Optional[Sequence['outputs.NetworkDnsForwarder']] = None,
                 hosts: Optional[Sequence['outputs.NetworkDnsHost']] = None,
                 local_only: Optional[bool] = None,
                 srvs: Optional[Sequence['outputs.NetworkDnsSrv']] = None):
        """
        :param bool enabled: when false, disable the DHCP server
        :param Sequence['NetworkDnsForwarderArgs'] forwarders: Either `address`, `domain`, or both must be set
        :param Sequence['NetworkDnsHostArgs'] hosts: a DNS host entry block. You can have one or more of these
               blocks in your DNS definition. You must specify both `ip` and `hostname`.
               
               An advanced example of round-robin DNS (using DNS host templates) follows:
        :param bool local_only: true/false: true means 'do not forward unresolved requests for this domain to the part DNS server
        :param Sequence['NetworkDnsSrvArgs'] srvs: a DNS SRV entry block. You can have one or more of these blocks
               in your DNS definition. You must specify `service` and `protocol`.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if forwarders is not None:
            pulumi.set(__self__, "forwarders", forwarders)
        if hosts is not None:
            pulumi.set(__self__, "hosts", hosts)
        if local_only is not None:
            pulumi.set(__self__, "local_only", local_only)
        if srvs is not None:
            pulumi.set(__self__, "srvs", srvs)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        when false, disable the DHCP server
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def forwarders(self) -> Optional[Sequence['outputs.NetworkDnsForwarder']]:
        """
        Either `address`, `domain`, or both must be set
        """
        return pulumi.get(self, "forwarders")

    @property
    @pulumi.getter
    def hosts(self) -> Optional[Sequence['outputs.NetworkDnsHost']]:
        """
        a DNS host entry block. You can have one or more of these
        blocks in your DNS definition. You must specify both `ip` and `hostname`.

        An advanced example of round-robin DNS (using DNS host templates) follows:
        """
        return pulumi.get(self, "hosts")

    @property
    @pulumi.getter(name="localOnly")
    def local_only(self) -> Optional[bool]:
        """
        true/false: true means 'do not forward unresolved requests for this domain to the part DNS server
        """
        return pulumi.get(self, "local_only")

    @property
    @pulumi.getter
    def srvs(self) -> Optional[Sequence['outputs.NetworkDnsSrv']]:
        """
        a DNS SRV entry block. You can have one or more of these blocks
        in your DNS definition. You must specify `service` and `protocol`.
        """
        return pulumi.get(self, "srvs")


@pulumi.output_type
class NetworkDnsForwarder(dict):
    def __init__(__self__, *,
                 address: Optional[str] = None,
                 domain: Optional[str] = None):
        """
        :param str domain: The domain used by the DNS server.
        """
        if address is not None:
            pulumi.set(__self__, "address", address)
        if domain is not None:
            pulumi.set(__self__, "domain", domain)

    @property
    @pulumi.getter
    def address(self) -> Optional[str]:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter
    def domain(self) -> Optional[str]:
        """
        The domain used by the DNS server.
        """
        return pulumi.get(self, "domain")


@pulumi.output_type
class NetworkDnsHost(dict):
    def __init__(__self__, *,
                 hostname: Optional[str] = None,
                 ip: Optional[str] = None):
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if ip is not None:
            pulumi.set(__self__, "ip", ip)

    @property
    @pulumi.getter
    def hostname(self) -> Optional[str]:
        return pulumi.get(self, "hostname")

    @property
    @pulumi.getter
    def ip(self) -> Optional[str]:
        return pulumi.get(self, "ip")


@pulumi.output_type
class NetworkDnsSrv(dict):
    def __init__(__self__, *,
                 domain: Optional[str] = None,
                 port: Optional[str] = None,
                 priority: Optional[str] = None,
                 protocol: Optional[str] = None,
                 service: Optional[str] = None,
                 target: Optional[str] = None,
                 weight: Optional[str] = None):
        """
        :param str domain: The domain used by the DNS server.
        """
        if domain is not None:
            pulumi.set(__self__, "domain", domain)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if priority is not None:
            pulumi.set(__self__, "priority", priority)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)
        if service is not None:
            pulumi.set(__self__, "service", service)
        if target is not None:
            pulumi.set(__self__, "target", target)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter
    def domain(self) -> Optional[str]:
        """
        The domain used by the DNS server.
        """
        return pulumi.get(self, "domain")

    @property
    @pulumi.getter
    def port(self) -> Optional[str]:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def priority(self) -> Optional[str]:
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter
    def protocol(self) -> Optional[str]:
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter
    def service(self) -> Optional[str]:
        return pulumi.get(self, "service")

    @property
    @pulumi.getter
    def target(self) -> Optional[str]:
        return pulumi.get(self, "target")

    @property
    @pulumi.getter
    def weight(self) -> Optional[str]:
        return pulumi.get(self, "weight")


@pulumi.output_type
class NetworkDnsmasqOptions(dict):
    def __init__(__self__, *,
                 options: Optional[Sequence['outputs.NetworkDnsmasqOptionsOption']] = None):
        """
        :param Sequence['NetworkDnsmasqOptionsOptionArgs'] options: a Dnsmasq option entry block. You can have one or more of these
               blocks in your definition. You must specify `option_name` while `option_value` is
               optional to support value-less options.
               
               An example of setting Dnsmasq options (using Dnsmasq option templates) follows:
        """
        if options is not None:
            pulumi.set(__self__, "options", options)

    @property
    @pulumi.getter
    def options(self) -> Optional[Sequence['outputs.NetworkDnsmasqOptionsOption']]:
        """
        a Dnsmasq option entry block. You can have one or more of these
        blocks in your definition. You must specify `option_name` while `option_value` is
        optional to support value-less options.

        An example of setting Dnsmasq options (using Dnsmasq option templates) follows:
        """
        return pulumi.get(self, "options")


@pulumi.output_type
class NetworkDnsmasqOptionsOption(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "optionName":
            suggest = "option_name"
        elif key == "optionValue":
            suggest = "option_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkDnsmasqOptionsOption. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkDnsmasqOptionsOption.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkDnsmasqOptionsOption.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 option_name: Optional[str] = None,
                 option_value: Optional[str] = None):
        if option_name is not None:
            pulumi.set(__self__, "option_name", option_name)
        if option_value is not None:
            pulumi.set(__self__, "option_value", option_value)

    @property
    @pulumi.getter(name="optionName")
    def option_name(self) -> Optional[str]:
        return pulumi.get(self, "option_name")

    @property
    @pulumi.getter(name="optionValue")
    def option_value(self) -> Optional[str]:
        return pulumi.get(self, "option_value")


@pulumi.output_type
class NetworkRoute(dict):
    def __init__(__self__, *,
                 cidr: str,
                 gateway: str):
        pulumi.set(__self__, "cidr", cidr)
        pulumi.set(__self__, "gateway", gateway)

    @property
    @pulumi.getter
    def cidr(self) -> str:
        return pulumi.get(self, "cidr")

    @property
    @pulumi.getter
    def gateway(self) -> str:
        return pulumi.get(self, "gateway")


@pulumi.output_type
class NetworkXml(dict):
    def __init__(__self__, *,
                 xslt: Optional[str] = None):
        if xslt is not None:
            pulumi.set(__self__, "xslt", xslt)

    @property
    @pulumi.getter
    def xslt(self) -> Optional[str]:
        return pulumi.get(self, "xslt")


@pulumi.output_type
class PoolSource(dict):
    def __init__(__self__, *,
                 devices: Optional[Sequence['outputs.PoolSourceDevice']] = None,
                 name: Optional[str] = None):
        """
        :param str name: A unique name for the resource, required by libvirt.
        """
        if devices is not None:
            pulumi.set(__self__, "devices", devices)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def devices(self) -> Optional[Sequence['outputs.PoolSourceDevice']]:
        return pulumi.get(self, "devices")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        A unique name for the resource, required by libvirt.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class PoolSourceDevice(dict):
    def __init__(__self__, *,
                 path: Optional[str] = None):
        """
        :param str path: **Deprecated** (Optional) use `path` in the `target` block.
        """
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        **Deprecated** (Optional) use `path` in the `target` block.
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class PoolTarget(dict):
    def __init__(__self__, *,
                 path: Optional[str] = None):
        """
        :param str path: **Deprecated** (Optional) use `path` in the `target` block.
        """
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        **Deprecated** (Optional) use `path` in the `target` block.
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class PoolXml(dict):
    def __init__(__self__, *,
                 xslt: Optional[str] = None):
        if xslt is not None:
            pulumi.set(__self__, "xslt", xslt)

    @property
    @pulumi.getter
    def xslt(self) -> Optional[str]:
        return pulumi.get(self, "xslt")


@pulumi.output_type
class VolumeXml(dict):
    def __init__(__self__, *,
                 xslt: Optional[str] = None):
        if xslt is not None:
            pulumi.set(__self__, "xslt", xslt)

    @property
    @pulumi.getter
    def xslt(self) -> Optional[str]:
        return pulumi.get(self, "xslt")


@pulumi.output_type
class GetNodeDeviceInfoCapabilityResult(dict):
    def __init__(__self__, *,
                 block: str,
                 bus: str,
                 class_: str,
                 description: str,
                 device: str,
                 domain: str,
                 drive_type: str,
                 drm_type: str,
                 function: str,
                 host: str,
                 iommu_group: 'outputs.GetNodeDeviceInfoCapabilityIommuGroupResult',
                 logical_block_size: str,
                 lun: str,
                 model: str,
                 num_blocks: str,
                 number: str,
                 protocol: str,
                 scsi_type: str,
                 serial: str,
                 size: str,
                 slot: str,
                 subclass: str,
                 target: str,
                 type: str,
                 unique_id: str,
                 address: Optional[str] = None,
                 capability: Optional[Mapping[str, str]] = None,
                 features: Optional[Sequence[str]] = None,
                 firmware: Optional[Mapping[str, str]] = None,
                 hardware: Optional[Mapping[str, str]] = None,
                 interface: Optional[str] = None,
                 link: Optional[Mapping[str, str]] = None,
                 product: Optional[Mapping[str, str]] = None,
                 vendor: Optional[Mapping[str, str]] = None):
        """
        :param str block: Block device name
        :param str bus: The bus within the host
        :param str class_: Device class
        :param str device: Which device within the \\
        :param str domain: Device PCI domain
        :param str drive_type: Device drive type
        :param str drm_type: Type of DRM device: `render` or `card`
        :param str function: Device PCI function
        :param str host: The SCSI host containing the device
        :param 'GetNodeDeviceInfoCapabilityIommuGroupArgs' iommu_group: Structure that holds IOMMU Group `number` and the list of devices that are part of the group
        :param str logical_block_size: Device logical block size
        :param str lun: The lun within the target
        :param str model: Device model
        :param str num_blocks: Number of blocks on the device
        :param str number: Device number
        :param str protocol: Device protocol
        :param str scsi_type: The type of SCSI device
        :param str serial: Device serial number
        :param str size: Device size in bytes
        :param str slot: Device PCI slot
        :param str subclass: Device subclass
        :param str target: The target within the bus
        :param str type: Device type: `pci`, `storage`, `usb`
        :param str unique_id: This optionally provides the value from the 'unique_id' file found in the scsi_host's directory
        :param str address: If present, the MAC address of the device
        :param Mapping[str, str] capability: Holds key `type` that describes the type of network interface: `80203` for IEEE 802.3 or `80211` for IEEE 802.11
        :param str interface: The interface name tied to this device
        :param Mapping[str, str] link: Optional to reflect the status of the link via `speed` and `state` keys
        :param Mapping[str, str] product: If present, the product `id` and `name` from the device ROM
        :param Mapping[str, str] vendor: If present, the vendor `id` and `name` from the device ROM
        """
        pulumi.set(__self__, "block", block)
        pulumi.set(__self__, "bus", bus)
        pulumi.set(__self__, "class_", class_)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "device", device)
        pulumi.set(__self__, "domain", domain)
        pulumi.set(__self__, "drive_type", drive_type)
        pulumi.set(__self__, "drm_type", drm_type)
        pulumi.set(__self__, "function", function)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "iommu_group", iommu_group)
        pulumi.set(__self__, "logical_block_size", logical_block_size)
        pulumi.set(__self__, "lun", lun)
        pulumi.set(__self__, "model", model)
        pulumi.set(__self__, "num_blocks", num_blocks)
        pulumi.set(__self__, "number", number)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "scsi_type", scsi_type)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "slot", slot)
        pulumi.set(__self__, "subclass", subclass)
        pulumi.set(__self__, "target", target)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "unique_id", unique_id)
        if address is not None:
            pulumi.set(__self__, "address", address)
        if capability is not None:
            pulumi.set(__self__, "capability", capability)
        if features is not None:
            pulumi.set(__self__, "features", features)
        if firmware is not None:
            pulumi.set(__self__, "firmware", firmware)
        if hardware is not None:
            pulumi.set(__self__, "hardware", hardware)
        if interface is not None:
            pulumi.set(__self__, "interface", interface)
        if link is not None:
            pulumi.set(__self__, "link", link)
        if product is not None:
            pulumi.set(__self__, "product", product)
        if vendor is not None:
            pulumi.set(__self__, "vendor", vendor)

    @property
    @pulumi.getter
    def block(self) -> str:
        """
        Block device name
        """
        return pulumi.get(self, "block")

    @property
    @pulumi.getter
    def bus(self) -> str:
        """
        The bus within the host
        """
        return pulumi.get(self, "bus")

    @property
    @pulumi.getter(name="class")
    def class_(self) -> str:
        """
        Device class
        """
        return pulumi.get(self, "class_")

    @property
    @pulumi.getter
    def description(self) -> str:
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def device(self) -> str:
        """
        Which device within the \\
        """
        return pulumi.get(self, "device")

    @property
    @pulumi.getter
    def domain(self) -> str:
        """
        Device PCI domain
        """
        return pulumi.get(self, "domain")

    @property
    @pulumi.getter(name="driveType")
    def drive_type(self) -> str:
        """
        Device drive type
        """
        return pulumi.get(self, "drive_type")

    @property
    @pulumi.getter(name="drmType")
    def drm_type(self) -> str:
        """
        Type of DRM device: `render` or `card`
        """
        return pulumi.get(self, "drm_type")

    @property
    @pulumi.getter
    def function(self) -> str:
        """
        Device PCI function
        """
        return pulumi.get(self, "function")

    @property
    @pulumi.getter
    def host(self) -> str:
        """
        The SCSI host containing the device
        """
        return pulumi.get(self, "host")

    @property
    @pulumi.getter(name="iommuGroup")
    def iommu_group(self) -> 'outputs.GetNodeDeviceInfoCapabilityIommuGroupResult':
        """
        Structure that holds IOMMU Group `number` and the list of devices that are part of the group
        """
        return pulumi.get(self, "iommu_group")

    @property
    @pulumi.getter(name="logicalBlockSize")
    def logical_block_size(self) -> str:
        """
        Device logical block size
        """
        return pulumi.get(self, "logical_block_size")

    @property
    @pulumi.getter
    def lun(self) -> str:
        """
        The lun within the target
        """
        return pulumi.get(self, "lun")

    @property
    @pulumi.getter
    def model(self) -> str:
        """
        Device model
        """
        return pulumi.get(self, "model")

    @property
    @pulumi.getter(name="numBlocks")
    def num_blocks(self) -> str:
        """
        Number of blocks on the device
        """
        return pulumi.get(self, "num_blocks")

    @property
    @pulumi.getter
    def number(self) -> str:
        """
        Device number
        """
        return pulumi.get(self, "number")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        Device protocol
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="scsiType")
    def scsi_type(self) -> str:
        """
        The type of SCSI device
        """
        return pulumi.get(self, "scsi_type")

    @property
    @pulumi.getter
    def serial(self) -> str:
        """
        Device serial number
        """
        return pulumi.get(self, "serial")

    @property
    @pulumi.getter
    def size(self) -> str:
        """
        Device size in bytes
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter
    def slot(self) -> str:
        """
        Device PCI slot
        """
        return pulumi.get(self, "slot")

    @property
    @pulumi.getter
    def subclass(self) -> str:
        """
        Device subclass
        """
        return pulumi.get(self, "subclass")

    @property
    @pulumi.getter
    def target(self) -> str:
        """
        The target within the bus
        """
        return pulumi.get(self, "target")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Device type: `pci`, `storage`, `usb`
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="uniqueId")
    def unique_id(self) -> str:
        """
        This optionally provides the value from the 'unique_id' file found in the scsi_host's directory
        """
        return pulumi.get(self, "unique_id")

    @property
    @pulumi.getter
    def address(self) -> Optional[str]:
        """
        If present, the MAC address of the device
        """
        return pulumi.get(self, "address")

    @property
    @pulumi.getter
    def capability(self) -> Optional[Mapping[str, str]]:
        """
        Holds key `type` that describes the type of network interface: `80203` for IEEE 802.3 or `80211` for IEEE 802.11
        """
        return pulumi.get(self, "capability")

    @property
    @pulumi.getter
    def features(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "features")

    @property
    @pulumi.getter
    def firmware(self) -> Optional[Mapping[str, str]]:
        return pulumi.get(self, "firmware")

    @property
    @pulumi.getter
    def hardware(self) -> Optional[Mapping[str, str]]:
        return pulumi.get(self, "hardware")

    @property
    @pulumi.getter
    def interface(self) -> Optional[str]:
        """
        The interface name tied to this device
        """
        return pulumi.get(self, "interface")

    @property
    @pulumi.getter
    def link(self) -> Optional[Mapping[str, str]]:
        """
        Optional to reflect the status of the link via `speed` and `state` keys
        """
        return pulumi.get(self, "link")

    @property
    @pulumi.getter
    def product(self) -> Optional[Mapping[str, str]]:
        """
        If present, the product `id` and `name` from the device ROM
        """
        return pulumi.get(self, "product")

    @property
    @pulumi.getter
    def vendor(self) -> Optional[Mapping[str, str]]:
        """
        If present, the vendor `id` and `name` from the device ROM
        """
        return pulumi.get(self, "vendor")


@pulumi.output_type
class GetNodeDeviceInfoCapabilityIommuGroupResult(dict):
    def __init__(__self__, *,
                 addresses: Sequence[Mapping[str, str]],
                 number: str):
        """
        :param str number: Device number
        """
        pulumi.set(__self__, "addresses", addresses)
        pulumi.set(__self__, "number", number)

    @property
    @pulumi.getter
    def addresses(self) -> Sequence[Mapping[str, str]]:
        return pulumi.get(self, "addresses")

    @property
    @pulumi.getter
    def number(self) -> str:
        """
        Device number
        """
        return pulumi.get(self, "number")


@pulumi.output_type
class GetNodeDeviceInfoDevnodeResult(dict):
    def __init__(__self__, *,
                 path: str,
                 type: str):
        """
        :param str path: Full path of the device
        :param str type: Device type: `pci`, `storage`, `usb`
        """
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def path(self) -> str:
        """
        Full path of the device
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Device type: `pci`, `storage`, `usb`
        """
        return pulumi.get(self, "type")


