# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from ... import _utilities
from . import outputs
from ._enums import *

__all__ = [
    'ImageTemplateFileCustomizerResponse',
    'ImageTemplateIdentityResponse',
    'ImageTemplateIdentityResponseUserAssignedIdentities',
    'ImageTemplateLastRunStatusResponse',
    'ImageTemplateManagedImageDistributorResponse',
    'ImageTemplateManagedImageSourceResponse',
    'ImageTemplatePlatformImageSourceResponse',
    'ImageTemplatePowerShellCustomizerResponse',
    'ImageTemplateRestartCustomizerResponse',
    'ImageTemplateSharedImageDistributorResponse',
    'ImageTemplateSharedImageVersionSourceResponse',
    'ImageTemplateShellCustomizerResponse',
    'ImageTemplateVhdDistributorResponse',
    'ImageTemplateVmProfileResponse',
    'ImageTemplateWindowsUpdateCustomizerResponse',
    'PlatformImagePurchasePlanResponse',
    'ProvisioningErrorResponse',
    'VirtualNetworkConfigResponse',
]

@pulumi.output_type
class ImageTemplateFileCustomizerResponse(dict):
    """
    Uploads files to VMs (Linux, Windows). Corresponds to Packer file provisioner
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sha256Checksum":
            suggest = "sha256_checksum"
        elif key == "sourceUri":
            suggest = "source_uri"

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

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

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

    def __init__(__self__, *,
                 type: str,
                 destination: Optional[str] = None,
                 name: Optional[str] = None,
                 sha256_checksum: Optional[str] = None,
                 source_uri: Optional[str] = None):
        """
        Uploads files to VMs (Linux, Windows). Corresponds to Packer file provisioner
        :param str type: The type of customization tool you want to use on the Image. For example, "Shell" can be shell customizer
               Expected value is 'File'.
        :param str destination: The absolute path to a file (with nested directory structures already created) where the file (from sourceUri) will be uploaded to in the VM
        :param str name: Friendly Name to provide context on what this customization step does
        :param str sha256_checksum: SHA256 checksum of the file provided in the sourceUri field above
        :param str source_uri: The URI of the file to be uploaded for customizing the VM. It can be a github link, SAS URI for Azure Storage, etc
        """
        pulumi.set(__self__, "type", 'File')
        if destination is not None:
            pulumi.set(__self__, "destination", destination)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if sha256_checksum is None:
            sha256_checksum = ''
        if sha256_checksum is not None:
            pulumi.set(__self__, "sha256_checksum", sha256_checksum)
        if source_uri is not None:
            pulumi.set(__self__, "source_uri", source_uri)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of customization tool you want to use on the Image. For example, "Shell" can be shell customizer
        Expected value is 'File'.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def destination(self) -> Optional[str]:
        """
        The absolute path to a file (with nested directory structures already created) where the file (from sourceUri) will be uploaded to in the VM
        """
        return pulumi.get(self, "destination")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        Friendly Name to provide context on what this customization step does
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="sha256Checksum")
    def sha256_checksum(self) -> Optional[str]:
        """
        SHA256 checksum of the file provided in the sourceUri field above
        """
        return pulumi.get(self, "sha256_checksum")

    @property
    @pulumi.getter(name="sourceUri")
    def source_uri(self) -> Optional[str]:
        """
        The URI of the file to be uploaded for customizing the VM. It can be a github link, SAS URI for Azure Storage, etc
        """
        return pulumi.get(self, "source_uri")


@pulumi.output_type
class ImageTemplateIdentityResponse(dict):
    """
    Identity for the image template.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "userAssignedIdentities":
            suggest = "user_assigned_identities"

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

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

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

    def __init__(__self__, *,
                 type: Optional[str] = None,
                 user_assigned_identities: Optional[Mapping[str, 'outputs.ImageTemplateIdentityResponseUserAssignedIdentities']] = None):
        """
        Identity for the image template.
        :param str type: The type of identity used for the image template. The type 'None' will remove any identities from the image template.
        :param Mapping[str, 'ImageTemplateIdentityResponseUserAssignedIdentities'] user_assigned_identities: The list of user identities associated with the image template. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
        """
        if type is not None:
            pulumi.set(__self__, "type", type)
        if user_assigned_identities is not None:
            pulumi.set(__self__, "user_assigned_identities", user_assigned_identities)

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        The type of identity used for the image template. The type 'None' will remove any identities from the image template.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="userAssignedIdentities")
    def user_assigned_identities(self) -> Optional[Mapping[str, 'outputs.ImageTemplateIdentityResponseUserAssignedIdentities']]:
        """
        The list of user identities associated with the image template. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
        """
        return pulumi.get(self, "user_assigned_identities")


@pulumi.output_type
class ImageTemplateIdentityResponseUserAssignedIdentities(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientId":
            suggest = "client_id"
        elif key == "principalId":
            suggest = "principal_id"

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

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

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

    def __init__(__self__, *,
                 client_id: str,
                 principal_id: str):
        """
        :param str client_id: The client id of user assigned identity.
        :param str principal_id: The principal id of user assigned identity.
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "principal_id", principal_id)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> str:
        """
        The client id of user assigned identity.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> str:
        """
        The principal id of user assigned identity.
        """
        return pulumi.get(self, "principal_id")


@pulumi.output_type
class ImageTemplateLastRunStatusResponse(dict):
    """
    Describes the latest status of running an image template
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "endTime":
            suggest = "end_time"
        elif key == "runState":
            suggest = "run_state"
        elif key == "runSubState":
            suggest = "run_sub_state"
        elif key == "startTime":
            suggest = "start_time"

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

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

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

    def __init__(__self__, *,
                 end_time: Optional[str] = None,
                 message: Optional[str] = None,
                 run_state: Optional[str] = None,
                 run_sub_state: Optional[str] = None,
                 start_time: Optional[str] = None):
        """
        Describes the latest status of running an image template
        :param str end_time: End time of the last run (UTC)
        :param str message: Verbose information about the last run state
        :param str run_state: State of the last run
        :param str run_sub_state: Sub-state of the last run
        :param str start_time: Start time of the last run (UTC)
        """
        if end_time is not None:
            pulumi.set(__self__, "end_time", end_time)
        if message is not None:
            pulumi.set(__self__, "message", message)
        if run_state is not None:
            pulumi.set(__self__, "run_state", run_state)
        if run_sub_state is not None:
            pulumi.set(__self__, "run_sub_state", run_sub_state)
        if start_time is not None:
            pulumi.set(__self__, "start_time", start_time)

    @property
    @pulumi.getter(name="endTime")
    def end_time(self) -> Optional[str]:
        """
        End time of the last run (UTC)
        """
        return pulumi.get(self, "end_time")

    @property
    @pulumi.getter
    def message(self) -> Optional[str]:
        """
        Verbose information about the last run state
        """
        return pulumi.get(self, "message")

    @property
    @pulumi.getter(name="runState")
    def run_state(self) -> Optional[str]:
        """
        State of the last run
        """
        return pulumi.get(self, "run_state")

    @property
    @pulumi.getter(name="runSubState")
    def run_sub_state(self) -> Optional[str]:
        """
        Sub-state of the last run
        """
        return pulumi.get(self, "run_sub_state")

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> Optional[str]:
        """
        Start time of the last run (UTC)
        """
        return pulumi.get(self, "start_time")


@pulumi.output_type
class ImageTemplateManagedImageDistributorResponse(dict):
    """
    Distribute as a Managed Disk Image.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "imageId":
            suggest = "image_id"
        elif key == "runOutputName":
            suggest = "run_output_name"
        elif key == "artifactTags":
            suggest = "artifact_tags"

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

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

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

    def __init__(__self__, *,
                 image_id: str,
                 location: str,
                 run_output_name: str,
                 type: str,
                 artifact_tags: Optional[Mapping[str, str]] = None):
        """
        Distribute as a Managed Disk Image.
        :param str image_id: Resource Id of the Managed Disk Image
        :param str location: Azure location for the image, should match if image already exists
        :param str run_output_name: The name to be used for the associated RunOutput.
        :param str type: Type of distribution.
               Expected value is 'ManagedImage'.
        :param Mapping[str, str] artifact_tags: Tags that will be applied to the artifact once it has been created/updated by the distributor.
        """
        pulumi.set(__self__, "image_id", image_id)
        pulumi.set(__self__, "location", location)
        pulumi.set(__self__, "run_output_name", run_output_name)
        pulumi.set(__self__, "type", 'ManagedImage')
        if artifact_tags is not None:
            pulumi.set(__self__, "artifact_tags", artifact_tags)

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> str:
        """
        Resource Id of the Managed Disk Image
        """
        return pulumi.get(self, "image_id")

    @property
    @pulumi.getter
    def location(self) -> str:
        """
        Azure location for the image, should match if image already exists
        """
        return pulumi.get(self, "location")

    @property
    @pulumi.getter(name="runOutputName")
    def run_output_name(self) -> str:
        """
        The name to be used for the associated RunOutput.
        """
        return pulumi.get(self, "run_output_name")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Type of distribution.
        Expected value is 'ManagedImage'.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="artifactTags")
    def artifact_tags(self) -> Optional[Mapping[str, str]]:
        """
        Tags that will be applied to the artifact once it has been created/updated by the distributor.
        """
        return pulumi.get(self, "artifact_tags")


@pulumi.output_type
class ImageTemplateManagedImageSourceResponse(dict):
    """
    Describes an image source that is a managed image in customer subscription.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "imageId":
            suggest = "image_id"

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

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

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

    def __init__(__self__, *,
                 image_id: str,
                 type: str):
        """
        Describes an image source that is a managed image in customer subscription.
        :param str image_id: ARM resource id of the managed image in customer subscription
        :param str type: Specifies the type of source image you want to start with.
               Expected value is 'ManagedImage'.
        """
        pulumi.set(__self__, "image_id", image_id)
        pulumi.set(__self__, "type", 'ManagedImage')

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> str:
        """
        ARM resource id of the managed image in customer subscription
        """
        return pulumi.get(self, "image_id")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Specifies the type of source image you want to start with.
        Expected value is 'ManagedImage'.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class ImageTemplatePlatformImageSourceResponse(dict):
    """
    Describes an image source from [Azure Gallery Images](https://docs.microsoft.com/en-us/rest/api/compute/virtualmachineimages).
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "planInfo":
            suggest = "plan_info"

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

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

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

    def __init__(__self__, *,
                 type: str,
                 offer: Optional[str] = None,
                 plan_info: Optional['outputs.PlatformImagePurchasePlanResponse'] = None,
                 publisher: Optional[str] = None,
                 sku: Optional[str] = None,
                 version: Optional[str] = None):
        """
        Describes an image source from [Azure Gallery Images](https://docs.microsoft.com/en-us/rest/api/compute/virtualmachineimages).
        :param str type: Specifies the type of source image you want to start with.
               Expected value is 'PlatformImage'.
        :param str offer: Image offer from the [Azure Gallery Images](https://docs.microsoft.com/en-us/rest/api/compute/virtualmachineimages).
        :param 'PlatformImagePurchasePlanResponse' plan_info: Optional configuration of purchase plan for platform image.
        :param str publisher: Image Publisher in [Azure Gallery Images](https://docs.microsoft.com/en-us/rest/api/compute/virtualmachineimages).
        :param str sku: Image sku from the [Azure Gallery Images](https://docs.microsoft.com/en-us/rest/api/compute/virtualmachineimages).
        :param str version: Image version from the [Azure Gallery Images](https://docs.microsoft.com/en-us/rest/api/compute/virtualmachineimages). If 'latest' is specified here, the version is evaluated when the image build takes place, not when the template is submitted. Specifying 'latest' could cause ROUNDTRIP_INCONSISTENT_PROPERTY issue which will be fixed.
        """
        pulumi.set(__self__, "type", 'PlatformImage')
        if offer is not None:
            pulumi.set(__self__, "offer", offer)
        if plan_info is not None:
            pulumi.set(__self__, "plan_info", plan_info)
        if publisher is not None:
            pulumi.set(__self__, "publisher", publisher)
        if sku is not None:
            pulumi.set(__self__, "sku", sku)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Specifies the type of source image you want to start with.
        Expected value is 'PlatformImage'.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def offer(self) -> Optional[str]:
        """
        Image offer from the [Azure Gallery Images](https://docs.microsoft.com/en-us/rest/api/compute/virtualmachineimages).
        """
        return pulumi.get(self, "offer")

    @property
    @pulumi.getter(name="planInfo")
    def plan_info(self) -> Optional['outputs.PlatformImagePurchasePlanResponse']:
        """
        Optional configuration of purchase plan for platform image.
        """
        return pulumi.get(self, "plan_info")

    @property
    @pulumi.getter
    def publisher(self) -> Optional[str]:
        """
        Image Publisher in [Azure Gallery Images](https://docs.microsoft.com/en-us/rest/api/compute/virtualmachineimages).
        """
        return pulumi.get(self, "publisher")

    @property
    @pulumi.getter
    def sku(self) -> Optional[str]:
        """
        Image sku from the [Azure Gallery Images](https://docs.microsoft.com/en-us/rest/api/compute/virtualmachineimages).
        """
        return pulumi.get(self, "sku")

    @property
    @pulumi.getter
    def version(self) -> Optional[str]:
        """
        Image version from the [Azure Gallery Images](https://docs.microsoft.com/en-us/rest/api/compute/virtualmachineimages). If 'latest' is specified here, the version is evaluated when the image build takes place, not when the template is submitted. Specifying 'latest' could cause ROUNDTRIP_INCONSISTENT_PROPERTY issue which will be fixed.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class ImageTemplatePowerShellCustomizerResponse(dict):
    """
    Runs the specified PowerShell on the VM (Windows). Corresponds to Packer powershell provisioner. Exactly one of 'scriptUri' or 'inline' can be specified.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "runAsSystem":
            suggest = "run_as_system"
        elif key == "runElevated":
            suggest = "run_elevated"
        elif key == "scriptUri":
            suggest = "script_uri"
        elif key == "sha256Checksum":
            suggest = "sha256_checksum"
        elif key == "validExitCodes":
            suggest = "valid_exit_codes"

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

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

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

    def __init__(__self__, *,
                 type: str,
                 inline: Optional[Sequence[str]] = None,
                 name: Optional[str] = None,
                 run_as_system: Optional[bool] = None,
                 run_elevated: Optional[bool] = None,
                 script_uri: Optional[str] = None,
                 sha256_checksum: Optional[str] = None,
                 valid_exit_codes: Optional[Sequence[int]] = None):
        """
        Runs the specified PowerShell on the VM (Windows). Corresponds to Packer powershell provisioner. Exactly one of 'scriptUri' or 'inline' can be specified.
        :param str type: The type of customization tool you want to use on the Image. For example, "Shell" can be shell customizer
               Expected value is 'PowerShell'.
        :param Sequence[str] inline: Array of PowerShell commands to execute
        :param str name: Friendly Name to provide context on what this customization step does
        :param bool run_as_system: If specified, the PowerShell script will be run with elevated privileges using the Local System user. Can only be true when the runElevated field above is set to true.
        :param bool run_elevated: If specified, the PowerShell script will be run with elevated privileges
        :param str script_uri: URI of the PowerShell script to be run for customizing. It can be a github link, SAS URI for Azure Storage, etc
        :param str sha256_checksum: SHA256 checksum of the power shell script provided in the scriptUri field above
        :param Sequence[int] valid_exit_codes: Valid exit codes for the PowerShell script. [Default: 0]
        """
        pulumi.set(__self__, "type", 'PowerShell')
        if inline is not None:
            pulumi.set(__self__, "inline", inline)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if run_as_system is None:
            run_as_system = False
        if run_as_system is not None:
            pulumi.set(__self__, "run_as_system", run_as_system)
        if run_elevated is None:
            run_elevated = False
        if run_elevated is not None:
            pulumi.set(__self__, "run_elevated", run_elevated)
        if script_uri is not None:
            pulumi.set(__self__, "script_uri", script_uri)
        if sha256_checksum is None:
            sha256_checksum = ''
        if sha256_checksum is not None:
            pulumi.set(__self__, "sha256_checksum", sha256_checksum)
        if valid_exit_codes is not None:
            pulumi.set(__self__, "valid_exit_codes", valid_exit_codes)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of customization tool you want to use on the Image. For example, "Shell" can be shell customizer
        Expected value is 'PowerShell'.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def inline(self) -> Optional[Sequence[str]]:
        """
        Array of PowerShell commands to execute
        """
        return pulumi.get(self, "inline")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        Friendly Name to provide context on what this customization step does
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="runAsSystem")
    def run_as_system(self) -> Optional[bool]:
        """
        If specified, the PowerShell script will be run with elevated privileges using the Local System user. Can only be true when the runElevated field above is set to true.
        """
        return pulumi.get(self, "run_as_system")

    @property
    @pulumi.getter(name="runElevated")
    def run_elevated(self) -> Optional[bool]:
        """
        If specified, the PowerShell script will be run with elevated privileges
        """
        return pulumi.get(self, "run_elevated")

    @property
    @pulumi.getter(name="scriptUri")
    def script_uri(self) -> Optional[str]:
        """
        URI of the PowerShell script to be run for customizing. It can be a github link, SAS URI for Azure Storage, etc
        """
        return pulumi.get(self, "script_uri")

    @property
    @pulumi.getter(name="sha256Checksum")
    def sha256_checksum(self) -> Optional[str]:
        """
        SHA256 checksum of the power shell script provided in the scriptUri field above
        """
        return pulumi.get(self, "sha256_checksum")

    @property
    @pulumi.getter(name="validExitCodes")
    def valid_exit_codes(self) -> Optional[Sequence[int]]:
        """
        Valid exit codes for the PowerShell script. [Default: 0]
        """
        return pulumi.get(self, "valid_exit_codes")


@pulumi.output_type
class ImageTemplateRestartCustomizerResponse(dict):
    """
    Reboots a VM and waits for it to come back online (Windows). Corresponds to Packer windows-restart provisioner
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "restartCheckCommand":
            suggest = "restart_check_command"
        elif key == "restartCommand":
            suggest = "restart_command"
        elif key == "restartTimeout":
            suggest = "restart_timeout"

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

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

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

    def __init__(__self__, *,
                 type: str,
                 name: Optional[str] = None,
                 restart_check_command: Optional[str] = None,
                 restart_command: Optional[str] = None,
                 restart_timeout: Optional[str] = None):
        """
        Reboots a VM and waits for it to come back online (Windows). Corresponds to Packer windows-restart provisioner
        :param str type: The type of customization tool you want to use on the Image. For example, "Shell" can be shell customizer
               Expected value is 'WindowsRestart'.
        :param str name: Friendly Name to provide context on what this customization step does
        :param str restart_check_command: Command to check if restart succeeded [Default: '']
        :param str restart_command: Command to execute the restart [Default: 'shutdown /r /f /t 0 /c "packer restart"']
        :param str restart_timeout: Restart timeout specified as a string of magnitude and unit, e.g. '5m' (5 minutes) or '2h' (2 hours) [Default: '5m']
        """
        pulumi.set(__self__, "type", 'WindowsRestart')
        if name is not None:
            pulumi.set(__self__, "name", name)
        if restart_check_command is not None:
            pulumi.set(__self__, "restart_check_command", restart_check_command)
        if restart_command is not None:
            pulumi.set(__self__, "restart_command", restart_command)
        if restart_timeout is not None:
            pulumi.set(__self__, "restart_timeout", restart_timeout)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of customization tool you want to use on the Image. For example, "Shell" can be shell customizer
        Expected value is 'WindowsRestart'.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        Friendly Name to provide context on what this customization step does
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="restartCheckCommand")
    def restart_check_command(self) -> Optional[str]:
        """
        Command to check if restart succeeded [Default: '']
        """
        return pulumi.get(self, "restart_check_command")

    @property
    @pulumi.getter(name="restartCommand")
    def restart_command(self) -> Optional[str]:
        """
        Command to execute the restart [Default: 'shutdown /r /f /t 0 /c "packer restart"']
        """
        return pulumi.get(self, "restart_command")

    @property
    @pulumi.getter(name="restartTimeout")
    def restart_timeout(self) -> Optional[str]:
        """
        Restart timeout specified as a string of magnitude and unit, e.g. '5m' (5 minutes) or '2h' (2 hours) [Default: '5m']
        """
        return pulumi.get(self, "restart_timeout")


@pulumi.output_type
class ImageTemplateSharedImageDistributorResponse(dict):
    """
    Distribute via Shared Image Gallery.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "galleryImageId":
            suggest = "gallery_image_id"
        elif key == "replicationRegions":
            suggest = "replication_regions"
        elif key == "runOutputName":
            suggest = "run_output_name"
        elif key == "artifactTags":
            suggest = "artifact_tags"
        elif key == "excludeFromLatest":
            suggest = "exclude_from_latest"
        elif key == "storageAccountType":
            suggest = "storage_account_type"

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

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

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

    def __init__(__self__, *,
                 gallery_image_id: str,
                 replication_regions: Sequence[str],
                 run_output_name: str,
                 type: str,
                 artifact_tags: Optional[Mapping[str, str]] = None,
                 exclude_from_latest: Optional[bool] = None,
                 storage_account_type: Optional[str] = None):
        """
        Distribute via Shared Image Gallery.
        :param str gallery_image_id: Resource Id of the Shared Image Gallery image
        :param Sequence[str] replication_regions: A list of regions that the image will be replicated to
        :param str run_output_name: The name to be used for the associated RunOutput.
        :param str type: Type of distribution.
               Expected value is 'SharedImage'.
        :param Mapping[str, str] artifact_tags: Tags that will be applied to the artifact once it has been created/updated by the distributor.
        :param bool exclude_from_latest: Flag that indicates whether created image version should be excluded from latest. Omit to use the default (false).
        :param str storage_account_type: Storage account type to be used to store the shared image. Omit to use the default (Standard_LRS).
        """
        pulumi.set(__self__, "gallery_image_id", gallery_image_id)
        pulumi.set(__self__, "replication_regions", replication_regions)
        pulumi.set(__self__, "run_output_name", run_output_name)
        pulumi.set(__self__, "type", 'SharedImage')
        if artifact_tags is not None:
            pulumi.set(__self__, "artifact_tags", artifact_tags)
        if exclude_from_latest is None:
            exclude_from_latest = False
        if exclude_from_latest is not None:
            pulumi.set(__self__, "exclude_from_latest", exclude_from_latest)
        if storage_account_type is not None:
            pulumi.set(__self__, "storage_account_type", storage_account_type)

    @property
    @pulumi.getter(name="galleryImageId")
    def gallery_image_id(self) -> str:
        """
        Resource Id of the Shared Image Gallery image
        """
        return pulumi.get(self, "gallery_image_id")

    @property
    @pulumi.getter(name="replicationRegions")
    def replication_regions(self) -> Sequence[str]:
        """
        A list of regions that the image will be replicated to
        """
        return pulumi.get(self, "replication_regions")

    @property
    @pulumi.getter(name="runOutputName")
    def run_output_name(self) -> str:
        """
        The name to be used for the associated RunOutput.
        """
        return pulumi.get(self, "run_output_name")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Type of distribution.
        Expected value is 'SharedImage'.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="artifactTags")
    def artifact_tags(self) -> Optional[Mapping[str, str]]:
        """
        Tags that will be applied to the artifact once it has been created/updated by the distributor.
        """
        return pulumi.get(self, "artifact_tags")

    @property
    @pulumi.getter(name="excludeFromLatest")
    def exclude_from_latest(self) -> Optional[bool]:
        """
        Flag that indicates whether created image version should be excluded from latest. Omit to use the default (false).
        """
        return pulumi.get(self, "exclude_from_latest")

    @property
    @pulumi.getter(name="storageAccountType")
    def storage_account_type(self) -> Optional[str]:
        """
        Storage account type to be used to store the shared image. Omit to use the default (Standard_LRS).
        """
        return pulumi.get(self, "storage_account_type")


@pulumi.output_type
class ImageTemplateSharedImageVersionSourceResponse(dict):
    """
    Describes an image source that is an image version in a shared image gallery.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "imageVersionId":
            suggest = "image_version_id"

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

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

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

    def __init__(__self__, *,
                 image_version_id: str,
                 type: str):
        """
        Describes an image source that is an image version in a shared image gallery.
        :param str image_version_id: ARM resource id of the image version in the shared image gallery
        :param str type: Specifies the type of source image you want to start with.
               Expected value is 'SharedImageVersion'.
        """
        pulumi.set(__self__, "image_version_id", image_version_id)
        pulumi.set(__self__, "type", 'SharedImageVersion')

    @property
    @pulumi.getter(name="imageVersionId")
    def image_version_id(self) -> str:
        """
        ARM resource id of the image version in the shared image gallery
        """
        return pulumi.get(self, "image_version_id")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Specifies the type of source image you want to start with.
        Expected value is 'SharedImageVersion'.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class ImageTemplateShellCustomizerResponse(dict):
    """
    Runs a shell script during the customization phase (Linux). Corresponds to Packer shell provisioner. Exactly one of 'scriptUri' or 'inline' can be specified.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "scriptUri":
            suggest = "script_uri"
        elif key == "sha256Checksum":
            suggest = "sha256_checksum"

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

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

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

    def __init__(__self__, *,
                 type: str,
                 inline: Optional[Sequence[str]] = None,
                 name: Optional[str] = None,
                 script_uri: Optional[str] = None,
                 sha256_checksum: Optional[str] = None):
        """
        Runs a shell script during the customization phase (Linux). Corresponds to Packer shell provisioner. Exactly one of 'scriptUri' or 'inline' can be specified.
        :param str type: The type of customization tool you want to use on the Image. For example, "Shell" can be shell customizer
               Expected value is 'Shell'.
        :param Sequence[str] inline: Array of shell commands to execute
        :param str name: Friendly Name to provide context on what this customization step does
        :param str script_uri: URI of the shell script to be run for customizing. It can be a github link, SAS URI for Azure Storage, etc
        :param str sha256_checksum: SHA256 checksum of the shell script provided in the scriptUri field
        """
        pulumi.set(__self__, "type", 'Shell')
        if inline is not None:
            pulumi.set(__self__, "inline", inline)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if script_uri is not None:
            pulumi.set(__self__, "script_uri", script_uri)
        if sha256_checksum is None:
            sha256_checksum = ''
        if sha256_checksum is not None:
            pulumi.set(__self__, "sha256_checksum", sha256_checksum)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of customization tool you want to use on the Image. For example, "Shell" can be shell customizer
        Expected value is 'Shell'.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def inline(self) -> Optional[Sequence[str]]:
        """
        Array of shell commands to execute
        """
        return pulumi.get(self, "inline")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        Friendly Name to provide context on what this customization step does
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="scriptUri")
    def script_uri(self) -> Optional[str]:
        """
        URI of the shell script to be run for customizing. It can be a github link, SAS URI for Azure Storage, etc
        """
        return pulumi.get(self, "script_uri")

    @property
    @pulumi.getter(name="sha256Checksum")
    def sha256_checksum(self) -> Optional[str]:
        """
        SHA256 checksum of the shell script provided in the scriptUri field
        """
        return pulumi.get(self, "sha256_checksum")


@pulumi.output_type
class ImageTemplateVhdDistributorResponse(dict):
    """
    Distribute via VHD in a storage account.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "runOutputName":
            suggest = "run_output_name"
        elif key == "artifactTags":
            suggest = "artifact_tags"

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

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

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

    def __init__(__self__, *,
                 run_output_name: str,
                 type: str,
                 artifact_tags: Optional[Mapping[str, str]] = None):
        """
        Distribute via VHD in a storage account.
        :param str run_output_name: The name to be used for the associated RunOutput.
        :param str type: Type of distribution.
               Expected value is 'VHD'.
        :param Mapping[str, str] artifact_tags: Tags that will be applied to the artifact once it has been created/updated by the distributor.
        """
        pulumi.set(__self__, "run_output_name", run_output_name)
        pulumi.set(__self__, "type", 'VHD')
        if artifact_tags is not None:
            pulumi.set(__self__, "artifact_tags", artifact_tags)

    @property
    @pulumi.getter(name="runOutputName")
    def run_output_name(self) -> str:
        """
        The name to be used for the associated RunOutput.
        """
        return pulumi.get(self, "run_output_name")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Type of distribution.
        Expected value is 'VHD'.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="artifactTags")
    def artifact_tags(self) -> Optional[Mapping[str, str]]:
        """
        Tags that will be applied to the artifact once it has been created/updated by the distributor.
        """
        return pulumi.get(self, "artifact_tags")


@pulumi.output_type
class ImageTemplateVmProfileResponse(dict):
    """
    Describes the virtual machine used to build, customize and capture images
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "osDiskSizeGB":
            suggest = "os_disk_size_gb"
        elif key == "vmSize":
            suggest = "vm_size"
        elif key == "vnetConfig":
            suggest = "vnet_config"

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

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

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

    def __init__(__self__, *,
                 os_disk_size_gb: Optional[int] = None,
                 vm_size: Optional[str] = None,
                 vnet_config: Optional['outputs.VirtualNetworkConfigResponse'] = None):
        """
        Describes the virtual machine used to build, customize and capture images
        :param int os_disk_size_gb: Size of the OS disk in GB. Omit or specify 0 to use Azure's default OS disk size.
        :param str vm_size: Size of the virtual machine used to build, customize and capture images. Omit or specify empty string to use the default (Standard_D1_v2 for Gen1 images and Standard_D2ds_v4 for Gen2 images).
        :param 'VirtualNetworkConfigResponse' vnet_config: Optional configuration of the virtual network to use to deploy the build virtual machine in. Omit if no specific virtual network needs to be used.
        """
        if os_disk_size_gb is None:
            os_disk_size_gb = 0
        if os_disk_size_gb is not None:
            pulumi.set(__self__, "os_disk_size_gb", os_disk_size_gb)
        if vm_size is None:
            vm_size = ''
        if vm_size is not None:
            pulumi.set(__self__, "vm_size", vm_size)
        if vnet_config is not None:
            pulumi.set(__self__, "vnet_config", vnet_config)

    @property
    @pulumi.getter(name="osDiskSizeGB")
    def os_disk_size_gb(self) -> Optional[int]:
        """
        Size of the OS disk in GB. Omit or specify 0 to use Azure's default OS disk size.
        """
        return pulumi.get(self, "os_disk_size_gb")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> Optional[str]:
        """
        Size of the virtual machine used to build, customize and capture images. Omit or specify empty string to use the default (Standard_D1_v2 for Gen1 images and Standard_D2ds_v4 for Gen2 images).
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter(name="vnetConfig")
    def vnet_config(self) -> Optional['outputs.VirtualNetworkConfigResponse']:
        """
        Optional configuration of the virtual network to use to deploy the build virtual machine in. Omit if no specific virtual network needs to be used.
        """
        return pulumi.get(self, "vnet_config")


@pulumi.output_type
class ImageTemplateWindowsUpdateCustomizerResponse(dict):
    """
    Installs Windows Updates. Corresponds to Packer Windows Update Provisioner (https://github.com/rgl/packer-provisioner-windows-update)
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "searchCriteria":
            suggest = "search_criteria"
        elif key == "updateLimit":
            suggest = "update_limit"

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

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

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

    def __init__(__self__, *,
                 type: str,
                 filters: Optional[Sequence[str]] = None,
                 name: Optional[str] = None,
                 search_criteria: Optional[str] = None,
                 update_limit: Optional[int] = None):
        """
        Installs Windows Updates. Corresponds to Packer Windows Update Provisioner (https://github.com/rgl/packer-provisioner-windows-update)
        :param str type: The type of customization tool you want to use on the Image. For example, "Shell" can be shell customizer
               Expected value is 'WindowsUpdate'.
        :param Sequence[str] filters: Array of filters to select updates to apply. Omit or specify empty array to use the default (no filter). Refer to above link for examples and detailed description of this field.
        :param str name: Friendly Name to provide context on what this customization step does
        :param str search_criteria: Criteria to search updates. Omit or specify empty string to use the default (search all). Refer to above link for examples and detailed description of this field.
        :param int update_limit: Maximum number of updates to apply at a time. Omit or specify 0 to use the default (1000)
        """
        pulumi.set(__self__, "type", 'WindowsUpdate')
        if filters is not None:
            pulumi.set(__self__, "filters", filters)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if search_criteria is not None:
            pulumi.set(__self__, "search_criteria", search_criteria)
        if update_limit is not None:
            pulumi.set(__self__, "update_limit", update_limit)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of customization tool you want to use on the Image. For example, "Shell" can be shell customizer
        Expected value is 'WindowsUpdate'.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def filters(self) -> Optional[Sequence[str]]:
        """
        Array of filters to select updates to apply. Omit or specify empty array to use the default (no filter). Refer to above link for examples and detailed description of this field.
        """
        return pulumi.get(self, "filters")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        Friendly Name to provide context on what this customization step does
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="searchCriteria")
    def search_criteria(self) -> Optional[str]:
        """
        Criteria to search updates. Omit or specify empty string to use the default (search all). Refer to above link for examples and detailed description of this field.
        """
        return pulumi.get(self, "search_criteria")

    @property
    @pulumi.getter(name="updateLimit")
    def update_limit(self) -> Optional[int]:
        """
        Maximum number of updates to apply at a time. Omit or specify 0 to use the default (1000)
        """
        return pulumi.get(self, "update_limit")


@pulumi.output_type
class PlatformImagePurchasePlanResponse(dict):
    """
    Purchase plan configuration for platform image.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "planName":
            suggest = "plan_name"
        elif key == "planProduct":
            suggest = "plan_product"
        elif key == "planPublisher":
            suggest = "plan_publisher"

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

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

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

    def __init__(__self__, *,
                 plan_name: str,
                 plan_product: str,
                 plan_publisher: str):
        """
        Purchase plan configuration for platform image.
        :param str plan_name: Name of the purchase plan.
        :param str plan_product: Product of the purchase plan.
        :param str plan_publisher: Publisher of the purchase plan.
        """
        pulumi.set(__self__, "plan_name", plan_name)
        pulumi.set(__self__, "plan_product", plan_product)
        pulumi.set(__self__, "plan_publisher", plan_publisher)

    @property
    @pulumi.getter(name="planName")
    def plan_name(self) -> str:
        """
        Name of the purchase plan.
        """
        return pulumi.get(self, "plan_name")

    @property
    @pulumi.getter(name="planProduct")
    def plan_product(self) -> str:
        """
        Product of the purchase plan.
        """
        return pulumi.get(self, "plan_product")

    @property
    @pulumi.getter(name="planPublisher")
    def plan_publisher(self) -> str:
        """
        Publisher of the purchase plan.
        """
        return pulumi.get(self, "plan_publisher")


@pulumi.output_type
class ProvisioningErrorResponse(dict):
    """
    Describes the error happened when create or update an image template
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "provisioningErrorCode":
            suggest = "provisioning_error_code"

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

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

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

    def __init__(__self__, *,
                 message: Optional[str] = None,
                 provisioning_error_code: Optional[str] = None):
        """
        Describes the error happened when create or update an image template
        :param str message: Verbose error message about the provisioning failure
        :param str provisioning_error_code: Error code of the provisioning failure
        """
        if message is not None:
            pulumi.set(__self__, "message", message)
        if provisioning_error_code is not None:
            pulumi.set(__self__, "provisioning_error_code", provisioning_error_code)

    @property
    @pulumi.getter
    def message(self) -> Optional[str]:
        """
        Verbose error message about the provisioning failure
        """
        return pulumi.get(self, "message")

    @property
    @pulumi.getter(name="provisioningErrorCode")
    def provisioning_error_code(self) -> Optional[str]:
        """
        Error code of the provisioning failure
        """
        return pulumi.get(self, "provisioning_error_code")


@pulumi.output_type
class VirtualNetworkConfigResponse(dict):
    """
    Virtual Network configuration.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "subnetId":
            suggest = "subnet_id"

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

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

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

    def __init__(__self__, *,
                 subnet_id: Optional[str] = None):
        """
        Virtual Network configuration.
        :param str subnet_id: Resource id of a pre-existing subnet.
        """
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        Resource id of a pre-existing subnet.
        """
        return pulumi.get(self, "subnet_id")


