# 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 pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'VirtualMachineAgent',
    'VirtualMachineAudioDevice',
    'VirtualMachineCdrom',
    'VirtualMachineClone',
    'VirtualMachineCpu',
    'VirtualMachineDisk',
    'VirtualMachineDiskSpeed',
    'VirtualMachineEfiDisk',
    'VirtualMachineHostpci',
    'VirtualMachineInitialization',
    'VirtualMachineInitializationDns',
    'VirtualMachineInitializationIpConfig',
    'VirtualMachineInitializationIpConfigIpv4',
    'VirtualMachineInitializationIpConfigIpv6',
    'VirtualMachineInitializationUserAccount',
    'VirtualMachineMemory',
    'VirtualMachineNetworkDevice',
    'VirtualMachineOperatingSystem',
    'VirtualMachineSerialDevice',
    'VirtualMachineSmbios',
    'VirtualMachineStartup',
    'VirtualMachineVga',
    'GetVirtualMachinesVmResult',
]

@pulumi.output_type
class VirtualMachineAgent(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 timeout: Optional[str] = None,
                 trim: Optional[bool] = None,
                 type: Optional[str] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)
        if trim is not None:
            pulumi.set(__self__, "trim", trim)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

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

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

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


@pulumi.output_type
class VirtualMachineAudioDevice(dict):
    def __init__(__self__, *,
                 device: Optional[str] = None,
                 driver: Optional[str] = None,
                 enabled: Optional[bool] = None):
        if device is not None:
            pulumi.set(__self__, "device", device)
        if driver is not None:
            pulumi.set(__self__, "driver", driver)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

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

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

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


@pulumi.output_type
class VirtualMachineCdrom(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fileId":
            suggest = "file_id"

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

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

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

    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 file_id: Optional[str] = None,
                 interface: Optional[str] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if file_id is not None:
            pulumi.set(__self__, "file_id", file_id)
        if interface is not None:
            pulumi.set(__self__, "interface", interface)

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

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

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


@pulumi.output_type
class VirtualMachineClone(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vmId":
            suggest = "vm_id"
        elif key == "datastoreId":
            suggest = "datastore_id"
        elif key == "nodeName":
            suggest = "node_name"

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

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

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

    def __init__(__self__, *,
                 vm_id: int,
                 datastore_id: Optional[str] = None,
                 full: Optional[bool] = None,
                 node_name: Optional[str] = None,
                 retries: Optional[int] = None):
        pulumi.set(__self__, "vm_id", vm_id)
        if datastore_id is not None:
            pulumi.set(__self__, "datastore_id", datastore_id)
        if full is not None:
            pulumi.set(__self__, "full", full)
        if node_name is not None:
            pulumi.set(__self__, "node_name", node_name)
        if retries is not None:
            pulumi.set(__self__, "retries", retries)

    @property
    @pulumi.getter(name="vmId")
    def vm_id(self) -> int:
        return pulumi.get(self, "vm_id")

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

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

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

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


@pulumi.output_type
class VirtualMachineCpu(dict):
    def __init__(__self__, *,
                 architecture: Optional[str] = None,
                 cores: Optional[int] = None,
                 flags: Optional[Sequence[str]] = None,
                 hotplugged: Optional[int] = None,
                 numa: Optional[bool] = None,
                 sockets: Optional[int] = None,
                 type: Optional[str] = None,
                 units: Optional[int] = None):
        if architecture is not None:
            pulumi.set(__self__, "architecture", architecture)
        if cores is not None:
            pulumi.set(__self__, "cores", cores)
        if flags is not None:
            pulumi.set(__self__, "flags", flags)
        if hotplugged is not None:
            pulumi.set(__self__, "hotplugged", hotplugged)
        if numa is not None:
            pulumi.set(__self__, "numa", numa)
        if sockets is not None:
            pulumi.set(__self__, "sockets", sockets)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if units is not None:
            pulumi.set(__self__, "units", units)

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

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

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

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

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

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

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

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


@pulumi.output_type
class VirtualMachineDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "datastoreId":
            suggest = "datastore_id"
        elif key == "fileFormat":
            suggest = "file_format"
        elif key == "fileId":
            suggest = "file_id"

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

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

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

    def __init__(__self__, *,
                 interface: str,
                 cache: Optional[str] = None,
                 datastore_id: Optional[str] = None,
                 discard: Optional[str] = None,
                 file_format: Optional[str] = None,
                 file_id: Optional[str] = None,
                 iothread: Optional[bool] = None,
                 size: Optional[int] = None,
                 speed: Optional['outputs.VirtualMachineDiskSpeed'] = None,
                 ssd: Optional[bool] = None):
        pulumi.set(__self__, "interface", interface)
        if cache is not None:
            pulumi.set(__self__, "cache", cache)
        if datastore_id is not None:
            pulumi.set(__self__, "datastore_id", datastore_id)
        if discard is not None:
            pulumi.set(__self__, "discard", discard)
        if file_format is not None:
            pulumi.set(__self__, "file_format", file_format)
        if file_id is not None:
            pulumi.set(__self__, "file_id", file_id)
        if iothread is not None:
            pulumi.set(__self__, "iothread", iothread)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if speed is not None:
            pulumi.set(__self__, "speed", speed)
        if ssd is not None:
            pulumi.set(__self__, "ssd", ssd)

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class VirtualMachineDiskSpeed(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "readBurstable":
            suggest = "read_burstable"
        elif key == "writeBurstable":
            suggest = "write_burstable"

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

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

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

    def __init__(__self__, *,
                 read: Optional[int] = None,
                 read_burstable: Optional[int] = None,
                 write: Optional[int] = None,
                 write_burstable: Optional[int] = None):
        if read is not None:
            pulumi.set(__self__, "read", read)
        if read_burstable is not None:
            pulumi.set(__self__, "read_burstable", read_burstable)
        if write is not None:
            pulumi.set(__self__, "write", write)
        if write_burstable is not None:
            pulumi.set(__self__, "write_burstable", write_burstable)

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

    @property
    @pulumi.getter(name="readBurstable")
    def read_burstable(self) -> Optional[int]:
        return pulumi.get(self, "read_burstable")

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

    @property
    @pulumi.getter(name="writeBurstable")
    def write_burstable(self) -> Optional[int]:
        return pulumi.get(self, "write_burstable")


@pulumi.output_type
class VirtualMachineEfiDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "datastoreId":
            suggest = "datastore_id"
        elif key == "fileFormat":
            suggest = "file_format"
        elif key == "preEnrolledKeys":
            suggest = "pre_enrolled_keys"

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

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

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

    def __init__(__self__, *,
                 datastore_id: Optional[str] = None,
                 file_format: Optional[str] = None,
                 pre_enrolled_keys: Optional[bool] = None,
                 type: Optional[str] = None):
        if datastore_id is not None:
            pulumi.set(__self__, "datastore_id", datastore_id)
        if file_format is not None:
            pulumi.set(__self__, "file_format", file_format)
        if pre_enrolled_keys is not None:
            pulumi.set(__self__, "pre_enrolled_keys", pre_enrolled_keys)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

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

    @property
    @pulumi.getter(name="preEnrolledKeys")
    def pre_enrolled_keys(self) -> Optional[bool]:
        return pulumi.get(self, "pre_enrolled_keys")

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


@pulumi.output_type
class VirtualMachineHostpci(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "romFile":
            suggest = "rom_file"

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

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

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

    def __init__(__self__, *,
                 device: str,
                 id: Optional[str] = None,
                 mapping: Optional[str] = None,
                 mdev: Optional[str] = None,
                 pcie: Optional[bool] = None,
                 rom_file: Optional[str] = None,
                 rombar: Optional[bool] = None,
                 xvga: Optional[bool] = None):
        pulumi.set(__self__, "device", device)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if mapping is not None:
            pulumi.set(__self__, "mapping", mapping)
        if mdev is not None:
            pulumi.set(__self__, "mdev", mdev)
        if pcie is not None:
            pulumi.set(__self__, "pcie", pcie)
        if rom_file is not None:
            pulumi.set(__self__, "rom_file", rom_file)
        if rombar is not None:
            pulumi.set(__self__, "rombar", rombar)
        if xvga is not None:
            pulumi.set(__self__, "xvga", xvga)

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

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

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

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

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

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

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

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


@pulumi.output_type
class VirtualMachineInitialization(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "datastoreId":
            suggest = "datastore_id"
        elif key == "ipConfigs":
            suggest = "ip_configs"
        elif key == "metaDataFileId":
            suggest = "meta_data_file_id"
        elif key == "networkDataFileId":
            suggest = "network_data_file_id"
        elif key == "userAccount":
            suggest = "user_account"
        elif key == "userDataFileId":
            suggest = "user_data_file_id"
        elif key == "vendorDataFileId":
            suggest = "vendor_data_file_id"

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

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

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

    def __init__(__self__, *,
                 datastore_id: Optional[str] = None,
                 dns: Optional['outputs.VirtualMachineInitializationDns'] = None,
                 interface: Optional[str] = None,
                 ip_configs: Optional[Sequence['outputs.VirtualMachineInitializationIpConfig']] = None,
                 meta_data_file_id: Optional[str] = None,
                 network_data_file_id: Optional[str] = None,
                 type: Optional[str] = None,
                 user_account: Optional['outputs.VirtualMachineInitializationUserAccount'] = None,
                 user_data_file_id: Optional[str] = None,
                 vendor_data_file_id: Optional[str] = None):
        if datastore_id is not None:
            pulumi.set(__self__, "datastore_id", datastore_id)
        if dns is not None:
            pulumi.set(__self__, "dns", dns)
        if interface is not None:
            pulumi.set(__self__, "interface", interface)
        if ip_configs is not None:
            pulumi.set(__self__, "ip_configs", ip_configs)
        if meta_data_file_id is not None:
            pulumi.set(__self__, "meta_data_file_id", meta_data_file_id)
        if network_data_file_id is not None:
            pulumi.set(__self__, "network_data_file_id", network_data_file_id)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if user_account is not None:
            pulumi.set(__self__, "user_account", user_account)
        if user_data_file_id is not None:
            pulumi.set(__self__, "user_data_file_id", user_data_file_id)
        if vendor_data_file_id is not None:
            pulumi.set(__self__, "vendor_data_file_id", vendor_data_file_id)

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

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

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

    @property
    @pulumi.getter(name="ipConfigs")
    def ip_configs(self) -> Optional[Sequence['outputs.VirtualMachineInitializationIpConfig']]:
        return pulumi.get(self, "ip_configs")

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

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

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

    @property
    @pulumi.getter(name="userAccount")
    def user_account(self) -> Optional['outputs.VirtualMachineInitializationUserAccount']:
        return pulumi.get(self, "user_account")

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

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


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

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

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


@pulumi.output_type
class VirtualMachineInitializationIpConfig(dict):
    def __init__(__self__, *,
                 ipv4: Optional['outputs.VirtualMachineInitializationIpConfigIpv4'] = None,
                 ipv6: Optional['outputs.VirtualMachineInitializationIpConfigIpv6'] = None):
        if ipv4 is not None:
            pulumi.set(__self__, "ipv4", ipv4)
        if ipv6 is not None:
            pulumi.set(__self__, "ipv6", ipv6)

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

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


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

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

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


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

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

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


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

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

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

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


@pulumi.output_type
class VirtualMachineMemory(dict):
    def __init__(__self__, *,
                 dedicated: Optional[int] = None,
                 floating: Optional[int] = None,
                 shared: Optional[int] = None):
        if dedicated is not None:
            pulumi.set(__self__, "dedicated", dedicated)
        if floating is not None:
            pulumi.set(__self__, "floating", floating)
        if shared is not None:
            pulumi.set(__self__, "shared", shared)

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

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

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


@pulumi.output_type
class VirtualMachineNetworkDevice(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "macAddress":
            suggest = "mac_address"
        elif key == "rateLimit":
            suggest = "rate_limit"
        elif key == "vlanId":
            suggest = "vlan_id"

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

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

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

    def __init__(__self__, *,
                 bridge: Optional[str] = None,
                 enabled: Optional[bool] = None,
                 firewall: Optional[bool] = None,
                 mac_address: Optional[str] = None,
                 model: Optional[str] = None,
                 mtu: Optional[int] = None,
                 rate_limit: Optional[float] = None,
                 vlan_id: Optional[int] = None):
        if bridge is not None:
            pulumi.set(__self__, "bridge", bridge)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if firewall is not None:
            pulumi.set(__self__, "firewall", firewall)
        if mac_address is not None:
            pulumi.set(__self__, "mac_address", mac_address)
        if model is not None:
            pulumi.set(__self__, "model", model)
        if mtu is not None:
            pulumi.set(__self__, "mtu", mtu)
        if rate_limit is not None:
            pulumi.set(__self__, "rate_limit", rate_limit)
        if vlan_id is not None:
            pulumi.set(__self__, "vlan_id", vlan_id)

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

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

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

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

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

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

    @property
    @pulumi.getter(name="rateLimit")
    def rate_limit(self) -> Optional[float]:
        return pulumi.get(self, "rate_limit")

    @property
    @pulumi.getter(name="vlanId")
    def vlan_id(self) -> Optional[int]:
        return pulumi.get(self, "vlan_id")


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

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


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

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


@pulumi.output_type
class VirtualMachineSmbios(dict):
    def __init__(__self__, *,
                 family: Optional[str] = None,
                 manufacturer: Optional[str] = None,
                 product: Optional[str] = None,
                 serial: Optional[str] = None,
                 sku: Optional[str] = None,
                 uuid: Optional[str] = None,
                 version: Optional[str] = None):
        if family is not None:
            pulumi.set(__self__, "family", family)
        if manufacturer is not None:
            pulumi.set(__self__, "manufacturer", manufacturer)
        if product is not None:
            pulumi.set(__self__, "product", product)
        if serial is not None:
            pulumi.set(__self__, "serial", serial)
        if sku is not None:
            pulumi.set(__self__, "sku", sku)
        if uuid is not None:
            pulumi.set(__self__, "uuid", uuid)
        if version is not None:
            pulumi.set(__self__, "version", version)

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

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

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

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

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

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

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


@pulumi.output_type
class VirtualMachineStartup(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "downDelay":
            suggest = "down_delay"
        elif key == "upDelay":
            suggest = "up_delay"

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

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

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

    def __init__(__self__, *,
                 down_delay: Optional[int] = None,
                 order: Optional[int] = None,
                 up_delay: Optional[int] = None):
        if down_delay is not None:
            pulumi.set(__self__, "down_delay", down_delay)
        if order is not None:
            pulumi.set(__self__, "order", order)
        if up_delay is not None:
            pulumi.set(__self__, "up_delay", up_delay)

    @property
    @pulumi.getter(name="downDelay")
    def down_delay(self) -> Optional[int]:
        return pulumi.get(self, "down_delay")

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

    @property
    @pulumi.getter(name="upDelay")
    def up_delay(self) -> Optional[int]:
        return pulumi.get(self, "up_delay")


@pulumi.output_type
class VirtualMachineVga(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 memory: Optional[int] = None,
                 type: Optional[str] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

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

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


@pulumi.output_type
class GetVirtualMachinesVmResult(dict):
    def __init__(__self__, *,
                 name: str,
                 node_name: str,
                 tags: Sequence[str],
                 vm_id: int):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "node_name", node_name)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "vm_id", vm_id)

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

    @property
    @pulumi.getter(name="nodeName")
    def node_name(self) -> str:
        return pulumi.get(self, "node_name")

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

    @property
    @pulumi.getter(name="vmId")
    def vm_id(self) -> int:
        return pulumi.get(self, "vm_id")


