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

__all__ = [
    'Features',
    'FeaturesApiManagement',
    'FeaturesAppConfiguration',
    'FeaturesApplicationInsights',
    'FeaturesCognitiveAccount',
    'FeaturesKeyVault',
    'FeaturesLogAnalyticsWorkspace',
    'FeaturesManagedDisk',
    'FeaturesResourceGroup',
    'FeaturesSubscription',
    'FeaturesTemplateDeployment',
    'FeaturesVirtualMachine',
    'FeaturesVirtualMachineScaleSet',
]

@pulumi.output_type
class Features(dict):
    def __init__(__self__, *,
                 api_management: Optional['outputs.FeaturesApiManagement'] = None,
                 app_configuration: Optional['outputs.FeaturesAppConfiguration'] = None,
                 application_insights: Optional['outputs.FeaturesApplicationInsights'] = None,
                 cognitive_account: Optional['outputs.FeaturesCognitiveAccount'] = None,
                 key_vault: Optional['outputs.FeaturesKeyVault'] = None,
                 log_analytics_workspace: Optional['outputs.FeaturesLogAnalyticsWorkspace'] = None,
                 managed_disk: Optional['outputs.FeaturesManagedDisk'] = None,
                 resource_group: Optional['outputs.FeaturesResourceGroup'] = None,
                 subscription: Optional['outputs.FeaturesSubscription'] = None,
                 template_deployment: Optional['outputs.FeaturesTemplateDeployment'] = None,
                 virtual_machine: Optional['outputs.FeaturesVirtualMachine'] = None,
                 virtual_machine_scale_set: Optional['outputs.FeaturesVirtualMachineScaleSet'] = None):
        Features._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            api_management=api_management,
            app_configuration=app_configuration,
            application_insights=application_insights,
            cognitive_account=cognitive_account,
            key_vault=key_vault,
            log_analytics_workspace=log_analytics_workspace,
            managed_disk=managed_disk,
            resource_group=resource_group,
            subscription=subscription,
            template_deployment=template_deployment,
            virtual_machine=virtual_machine,
            virtual_machine_scale_set=virtual_machine_scale_set,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             api_management: Optional['outputs.FeaturesApiManagement'] = None,
             app_configuration: Optional['outputs.FeaturesAppConfiguration'] = None,
             application_insights: Optional['outputs.FeaturesApplicationInsights'] = None,
             cognitive_account: Optional['outputs.FeaturesCognitiveAccount'] = None,
             key_vault: Optional['outputs.FeaturesKeyVault'] = None,
             log_analytics_workspace: Optional['outputs.FeaturesLogAnalyticsWorkspace'] = None,
             managed_disk: Optional['outputs.FeaturesManagedDisk'] = None,
             resource_group: Optional['outputs.FeaturesResourceGroup'] = None,
             subscription: Optional['outputs.FeaturesSubscription'] = None,
             template_deployment: Optional['outputs.FeaturesTemplateDeployment'] = None,
             virtual_machine: Optional['outputs.FeaturesVirtualMachine'] = None,
             virtual_machine_scale_set: Optional['outputs.FeaturesVirtualMachineScaleSet'] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if api_management is None and 'apiManagement' in kwargs:
            api_management = kwargs['apiManagement']
        if app_configuration is None and 'appConfiguration' in kwargs:
            app_configuration = kwargs['appConfiguration']
        if application_insights is None and 'applicationInsights' in kwargs:
            application_insights = kwargs['applicationInsights']
        if cognitive_account is None and 'cognitiveAccount' in kwargs:
            cognitive_account = kwargs['cognitiveAccount']
        if key_vault is None and 'keyVault' in kwargs:
            key_vault = kwargs['keyVault']
        if log_analytics_workspace is None and 'logAnalyticsWorkspace' in kwargs:
            log_analytics_workspace = kwargs['logAnalyticsWorkspace']
        if managed_disk is None and 'managedDisk' in kwargs:
            managed_disk = kwargs['managedDisk']
        if resource_group is None and 'resourceGroup' in kwargs:
            resource_group = kwargs['resourceGroup']
        if template_deployment is None and 'templateDeployment' in kwargs:
            template_deployment = kwargs['templateDeployment']
        if virtual_machine is None and 'virtualMachine' in kwargs:
            virtual_machine = kwargs['virtualMachine']
        if virtual_machine_scale_set is None and 'virtualMachineScaleSet' in kwargs:
            virtual_machine_scale_set = kwargs['virtualMachineScaleSet']

        if api_management is not None:
            _setter("api_management", api_management)
        if app_configuration is not None:
            _setter("app_configuration", app_configuration)
        if application_insights is not None:
            _setter("application_insights", application_insights)
        if cognitive_account is not None:
            _setter("cognitive_account", cognitive_account)
        if key_vault is not None:
            _setter("key_vault", key_vault)
        if log_analytics_workspace is not None:
            _setter("log_analytics_workspace", log_analytics_workspace)
        if managed_disk is not None:
            _setter("managed_disk", managed_disk)
        if resource_group is not None:
            _setter("resource_group", resource_group)
        if subscription is not None:
            _setter("subscription", subscription)
        if template_deployment is not None:
            _setter("template_deployment", template_deployment)
        if virtual_machine is not None:
            _setter("virtual_machine", virtual_machine)
        if virtual_machine_scale_set is not None:
            _setter("virtual_machine_scale_set", virtual_machine_scale_set)

    @property
    @pulumi.getter(name="apiManagement")
    def api_management(self) -> Optional['outputs.FeaturesApiManagement']:
        return pulumi.get(self, "api_management")

    @property
    @pulumi.getter(name="appConfiguration")
    def app_configuration(self) -> Optional['outputs.FeaturesAppConfiguration']:
        return pulumi.get(self, "app_configuration")

    @property
    @pulumi.getter(name="applicationInsights")
    def application_insights(self) -> Optional['outputs.FeaturesApplicationInsights']:
        return pulumi.get(self, "application_insights")

    @property
    @pulumi.getter(name="cognitiveAccount")
    def cognitive_account(self) -> Optional['outputs.FeaturesCognitiveAccount']:
        return pulumi.get(self, "cognitive_account")

    @property
    @pulumi.getter(name="keyVault")
    def key_vault(self) -> Optional['outputs.FeaturesKeyVault']:
        return pulumi.get(self, "key_vault")

    @property
    @pulumi.getter(name="logAnalyticsWorkspace")
    def log_analytics_workspace(self) -> Optional['outputs.FeaturesLogAnalyticsWorkspace']:
        return pulumi.get(self, "log_analytics_workspace")

    @property
    @pulumi.getter(name="managedDisk")
    def managed_disk(self) -> Optional['outputs.FeaturesManagedDisk']:
        return pulumi.get(self, "managed_disk")

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> Optional['outputs.FeaturesResourceGroup']:
        return pulumi.get(self, "resource_group")

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

    @property
    @pulumi.getter(name="templateDeployment")
    def template_deployment(self) -> Optional['outputs.FeaturesTemplateDeployment']:
        return pulumi.get(self, "template_deployment")

    @property
    @pulumi.getter(name="virtualMachine")
    def virtual_machine(self) -> Optional['outputs.FeaturesVirtualMachine']:
        return pulumi.get(self, "virtual_machine")

    @property
    @pulumi.getter(name="virtualMachineScaleSet")
    def virtual_machine_scale_set(self) -> Optional['outputs.FeaturesVirtualMachineScaleSet']:
        return pulumi.get(self, "virtual_machine_scale_set")


@pulumi.output_type
class FeaturesApiManagement(dict):
    def __init__(__self__, *,
                 purge_soft_delete_on_destroy: Optional[bool] = None,
                 recover_soft_deleted: Optional[bool] = None):
        FeaturesApiManagement._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            purge_soft_delete_on_destroy=purge_soft_delete_on_destroy,
            recover_soft_deleted=recover_soft_deleted,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             purge_soft_delete_on_destroy: Optional[bool] = None,
             recover_soft_deleted: Optional[bool] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if purge_soft_delete_on_destroy is None and 'purgeSoftDeleteOnDestroy' in kwargs:
            purge_soft_delete_on_destroy = kwargs['purgeSoftDeleteOnDestroy']
        if recover_soft_deleted is None and 'recoverSoftDeleted' in kwargs:
            recover_soft_deleted = kwargs['recoverSoftDeleted']

        if purge_soft_delete_on_destroy is not None:
            _setter("purge_soft_delete_on_destroy", purge_soft_delete_on_destroy)
        if recover_soft_deleted is not None:
            _setter("recover_soft_deleted", recover_soft_deleted)

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

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


@pulumi.output_type
class FeaturesAppConfiguration(dict):
    def __init__(__self__, *,
                 purge_soft_delete_on_destroy: Optional[bool] = None,
                 recover_soft_deleted: Optional[bool] = None):
        FeaturesAppConfiguration._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            purge_soft_delete_on_destroy=purge_soft_delete_on_destroy,
            recover_soft_deleted=recover_soft_deleted,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             purge_soft_delete_on_destroy: Optional[bool] = None,
             recover_soft_deleted: Optional[bool] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if purge_soft_delete_on_destroy is None and 'purgeSoftDeleteOnDestroy' in kwargs:
            purge_soft_delete_on_destroy = kwargs['purgeSoftDeleteOnDestroy']
        if recover_soft_deleted is None and 'recoverSoftDeleted' in kwargs:
            recover_soft_deleted = kwargs['recoverSoftDeleted']

        if purge_soft_delete_on_destroy is not None:
            _setter("purge_soft_delete_on_destroy", purge_soft_delete_on_destroy)
        if recover_soft_deleted is not None:
            _setter("recover_soft_deleted", recover_soft_deleted)

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

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


@pulumi.output_type
class FeaturesApplicationInsights(dict):
    def __init__(__self__, *,
                 disable_generated_rule: Optional[bool] = None):
        FeaturesApplicationInsights._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            disable_generated_rule=disable_generated_rule,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             disable_generated_rule: Optional[bool] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if disable_generated_rule is None and 'disableGeneratedRule' in kwargs:
            disable_generated_rule = kwargs['disableGeneratedRule']

        if disable_generated_rule is not None:
            _setter("disable_generated_rule", disable_generated_rule)

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


@pulumi.output_type
class FeaturesCognitiveAccount(dict):
    def __init__(__self__, *,
                 purge_soft_delete_on_destroy: Optional[bool] = None):
        FeaturesCognitiveAccount._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            purge_soft_delete_on_destroy=purge_soft_delete_on_destroy,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             purge_soft_delete_on_destroy: Optional[bool] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if purge_soft_delete_on_destroy is None and 'purgeSoftDeleteOnDestroy' in kwargs:
            purge_soft_delete_on_destroy = kwargs['purgeSoftDeleteOnDestroy']

        if purge_soft_delete_on_destroy is not None:
            _setter("purge_soft_delete_on_destroy", purge_soft_delete_on_destroy)

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


@pulumi.output_type
class FeaturesKeyVault(dict):
    def __init__(__self__, *,
                 purge_soft_delete_on_destroy: Optional[bool] = None,
                 purge_soft_deleted_certificates_on_destroy: Optional[bool] = None,
                 purge_soft_deleted_hardware_security_modules_on_destroy: Optional[bool] = None,
                 purge_soft_deleted_keys_on_destroy: Optional[bool] = None,
                 purge_soft_deleted_secrets_on_destroy: Optional[bool] = None,
                 recover_soft_deleted_certificates: Optional[bool] = None,
                 recover_soft_deleted_key_vaults: Optional[bool] = None,
                 recover_soft_deleted_keys: Optional[bool] = None,
                 recover_soft_deleted_secrets: Optional[bool] = None):
        FeaturesKeyVault._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            purge_soft_delete_on_destroy=purge_soft_delete_on_destroy,
            purge_soft_deleted_certificates_on_destroy=purge_soft_deleted_certificates_on_destroy,
            purge_soft_deleted_hardware_security_modules_on_destroy=purge_soft_deleted_hardware_security_modules_on_destroy,
            purge_soft_deleted_keys_on_destroy=purge_soft_deleted_keys_on_destroy,
            purge_soft_deleted_secrets_on_destroy=purge_soft_deleted_secrets_on_destroy,
            recover_soft_deleted_certificates=recover_soft_deleted_certificates,
            recover_soft_deleted_key_vaults=recover_soft_deleted_key_vaults,
            recover_soft_deleted_keys=recover_soft_deleted_keys,
            recover_soft_deleted_secrets=recover_soft_deleted_secrets,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             purge_soft_delete_on_destroy: Optional[bool] = None,
             purge_soft_deleted_certificates_on_destroy: Optional[bool] = None,
             purge_soft_deleted_hardware_security_modules_on_destroy: Optional[bool] = None,
             purge_soft_deleted_keys_on_destroy: Optional[bool] = None,
             purge_soft_deleted_secrets_on_destroy: Optional[bool] = None,
             recover_soft_deleted_certificates: Optional[bool] = None,
             recover_soft_deleted_key_vaults: Optional[bool] = None,
             recover_soft_deleted_keys: Optional[bool] = None,
             recover_soft_deleted_secrets: Optional[bool] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if purge_soft_delete_on_destroy is None and 'purgeSoftDeleteOnDestroy' in kwargs:
            purge_soft_delete_on_destroy = kwargs['purgeSoftDeleteOnDestroy']
        if purge_soft_deleted_certificates_on_destroy is None and 'purgeSoftDeletedCertificatesOnDestroy' in kwargs:
            purge_soft_deleted_certificates_on_destroy = kwargs['purgeSoftDeletedCertificatesOnDestroy']
        if purge_soft_deleted_hardware_security_modules_on_destroy is None and 'purgeSoftDeletedHardwareSecurityModulesOnDestroy' in kwargs:
            purge_soft_deleted_hardware_security_modules_on_destroy = kwargs['purgeSoftDeletedHardwareSecurityModulesOnDestroy']
        if purge_soft_deleted_keys_on_destroy is None and 'purgeSoftDeletedKeysOnDestroy' in kwargs:
            purge_soft_deleted_keys_on_destroy = kwargs['purgeSoftDeletedKeysOnDestroy']
        if purge_soft_deleted_secrets_on_destroy is None and 'purgeSoftDeletedSecretsOnDestroy' in kwargs:
            purge_soft_deleted_secrets_on_destroy = kwargs['purgeSoftDeletedSecretsOnDestroy']
        if recover_soft_deleted_certificates is None and 'recoverSoftDeletedCertificates' in kwargs:
            recover_soft_deleted_certificates = kwargs['recoverSoftDeletedCertificates']
        if recover_soft_deleted_key_vaults is None and 'recoverSoftDeletedKeyVaults' in kwargs:
            recover_soft_deleted_key_vaults = kwargs['recoverSoftDeletedKeyVaults']
        if recover_soft_deleted_keys is None and 'recoverSoftDeletedKeys' in kwargs:
            recover_soft_deleted_keys = kwargs['recoverSoftDeletedKeys']
        if recover_soft_deleted_secrets is None and 'recoverSoftDeletedSecrets' in kwargs:
            recover_soft_deleted_secrets = kwargs['recoverSoftDeletedSecrets']

        if purge_soft_delete_on_destroy is not None:
            _setter("purge_soft_delete_on_destroy", purge_soft_delete_on_destroy)
        if purge_soft_deleted_certificates_on_destroy is not None:
            _setter("purge_soft_deleted_certificates_on_destroy", purge_soft_deleted_certificates_on_destroy)
        if purge_soft_deleted_hardware_security_modules_on_destroy is not None:
            _setter("purge_soft_deleted_hardware_security_modules_on_destroy", purge_soft_deleted_hardware_security_modules_on_destroy)
        if purge_soft_deleted_keys_on_destroy is not None:
            _setter("purge_soft_deleted_keys_on_destroy", purge_soft_deleted_keys_on_destroy)
        if purge_soft_deleted_secrets_on_destroy is not None:
            _setter("purge_soft_deleted_secrets_on_destroy", purge_soft_deleted_secrets_on_destroy)
        if recover_soft_deleted_certificates is not None:
            _setter("recover_soft_deleted_certificates", recover_soft_deleted_certificates)
        if recover_soft_deleted_key_vaults is not None:
            _setter("recover_soft_deleted_key_vaults", recover_soft_deleted_key_vaults)
        if recover_soft_deleted_keys is not None:
            _setter("recover_soft_deleted_keys", recover_soft_deleted_keys)
        if recover_soft_deleted_secrets is not None:
            _setter("recover_soft_deleted_secrets", recover_soft_deleted_secrets)

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class FeaturesLogAnalyticsWorkspace(dict):
    def __init__(__self__, *,
                 permanently_delete_on_destroy: Optional[bool] = None):
        FeaturesLogAnalyticsWorkspace._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            permanently_delete_on_destroy=permanently_delete_on_destroy,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             permanently_delete_on_destroy: Optional[bool] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if permanently_delete_on_destroy is None and 'permanentlyDeleteOnDestroy' in kwargs:
            permanently_delete_on_destroy = kwargs['permanentlyDeleteOnDestroy']

        if permanently_delete_on_destroy is not None:
            _setter("permanently_delete_on_destroy", permanently_delete_on_destroy)

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


@pulumi.output_type
class FeaturesManagedDisk(dict):
    def __init__(__self__, *,
                 expand_without_downtime: Optional[bool] = None):
        FeaturesManagedDisk._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            expand_without_downtime=expand_without_downtime,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             expand_without_downtime: Optional[bool] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if expand_without_downtime is None and 'expandWithoutDowntime' in kwargs:
            expand_without_downtime = kwargs['expandWithoutDowntime']

        if expand_without_downtime is not None:
            _setter("expand_without_downtime", expand_without_downtime)

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


@pulumi.output_type
class FeaturesResourceGroup(dict):
    def __init__(__self__, *,
                 prevent_deletion_if_contains_resources: Optional[bool] = None):
        FeaturesResourceGroup._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            prevent_deletion_if_contains_resources=prevent_deletion_if_contains_resources,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             prevent_deletion_if_contains_resources: Optional[bool] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if prevent_deletion_if_contains_resources is None and 'preventDeletionIfContainsResources' in kwargs:
            prevent_deletion_if_contains_resources = kwargs['preventDeletionIfContainsResources']

        if prevent_deletion_if_contains_resources is not None:
            _setter("prevent_deletion_if_contains_resources", prevent_deletion_if_contains_resources)

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


@pulumi.output_type
class FeaturesSubscription(dict):
    def __init__(__self__, *,
                 prevent_cancellation_on_destroy: Optional[bool] = None):
        FeaturesSubscription._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            prevent_cancellation_on_destroy=prevent_cancellation_on_destroy,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             prevent_cancellation_on_destroy: Optional[bool] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if prevent_cancellation_on_destroy is None and 'preventCancellationOnDestroy' in kwargs:
            prevent_cancellation_on_destroy = kwargs['preventCancellationOnDestroy']

        if prevent_cancellation_on_destroy is not None:
            _setter("prevent_cancellation_on_destroy", prevent_cancellation_on_destroy)

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


@pulumi.output_type
class FeaturesTemplateDeployment(dict):
    def __init__(__self__, *,
                 delete_nested_items_during_deletion: bool):
        FeaturesTemplateDeployment._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            delete_nested_items_during_deletion=delete_nested_items_during_deletion,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             delete_nested_items_during_deletion: Optional[bool] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if delete_nested_items_during_deletion is None and 'deleteNestedItemsDuringDeletion' in kwargs:
            delete_nested_items_during_deletion = kwargs['deleteNestedItemsDuringDeletion']
        if delete_nested_items_during_deletion is None:
            raise TypeError("Missing 'delete_nested_items_during_deletion' argument")

        _setter("delete_nested_items_during_deletion", delete_nested_items_during_deletion)

    @property
    @pulumi.getter(name="deleteNestedItemsDuringDeletion")
    def delete_nested_items_during_deletion(self) -> bool:
        return pulumi.get(self, "delete_nested_items_during_deletion")


@pulumi.output_type
class FeaturesVirtualMachine(dict):
    def __init__(__self__, *,
                 delete_os_disk_on_deletion: Optional[bool] = None,
                 graceful_shutdown: Optional[bool] = None,
                 skip_shutdown_and_force_delete: Optional[bool] = None):
        FeaturesVirtualMachine._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            delete_os_disk_on_deletion=delete_os_disk_on_deletion,
            graceful_shutdown=graceful_shutdown,
            skip_shutdown_and_force_delete=skip_shutdown_and_force_delete,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             delete_os_disk_on_deletion: Optional[bool] = None,
             graceful_shutdown: Optional[bool] = None,
             skip_shutdown_and_force_delete: Optional[bool] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if delete_os_disk_on_deletion is None and 'deleteOsDiskOnDeletion' in kwargs:
            delete_os_disk_on_deletion = kwargs['deleteOsDiskOnDeletion']
        if graceful_shutdown is None and 'gracefulShutdown' in kwargs:
            graceful_shutdown = kwargs['gracefulShutdown']
        if skip_shutdown_and_force_delete is None and 'skipShutdownAndForceDelete' in kwargs:
            skip_shutdown_and_force_delete = kwargs['skipShutdownAndForceDelete']

        if delete_os_disk_on_deletion is not None:
            _setter("delete_os_disk_on_deletion", delete_os_disk_on_deletion)
        if graceful_shutdown is not None:
            _setter("graceful_shutdown", graceful_shutdown)
        if skip_shutdown_and_force_delete is not None:
            _setter("skip_shutdown_and_force_delete", skip_shutdown_and_force_delete)

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

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

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


@pulumi.output_type
class FeaturesVirtualMachineScaleSet(dict):
    def __init__(__self__, *,
                 force_delete: Optional[bool] = None,
                 roll_instances_when_required: Optional[bool] = None,
                 scale_to_zero_before_deletion: Optional[bool] = None):
        FeaturesVirtualMachineScaleSet._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            force_delete=force_delete,
            roll_instances_when_required=roll_instances_when_required,
            scale_to_zero_before_deletion=scale_to_zero_before_deletion,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             force_delete: Optional[bool] = None,
             roll_instances_when_required: Optional[bool] = None,
             scale_to_zero_before_deletion: Optional[bool] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if force_delete is None and 'forceDelete' in kwargs:
            force_delete = kwargs['forceDelete']
        if roll_instances_when_required is None and 'rollInstancesWhenRequired' in kwargs:
            roll_instances_when_required = kwargs['rollInstancesWhenRequired']
        if scale_to_zero_before_deletion is None and 'scaleToZeroBeforeDeletion' in kwargs:
            scale_to_zero_before_deletion = kwargs['scaleToZeroBeforeDeletion']

        if force_delete is not None:
            _setter("force_delete", force_delete)
        if roll_instances_when_required is not None:
            _setter("roll_instances_when_required", roll_instances_when_required)
        if scale_to_zero_before_deletion is not None:
            _setter("scale_to_zero_before_deletion", scale_to_zero_before_deletion)

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

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

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


