pulumi-azure-native 2.33.1a1711356993__py3-none-any.whl → 2.34.0__py3-none-any.whl

pulumi_azure_native/recoveryservices/v20240201/_inputs.py

@@ -0,0 +1,688 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** 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 ._enums import *
+
+__all__ = [
+    'AzureMonitorAlertSettingsArgs',
+    'ClassicAlertSettingsArgs',
+    'CmkKekIdentityArgs',
+    'CmkKeyVaultPropertiesArgs',
+    'CrossSubscriptionRestoreSettingsArgs',
+    'IdentityDataArgs',
+    'ImmutabilitySettingsArgs',
+    'MonitoringSettingsArgs',
+    'RestoreSettingsArgs',
+    'SecuritySettingsArgs',
+    'SkuArgs',
+    'SoftDeleteSettingsArgs',
+    'VaultPropertiesEncryptionArgs',
+    'VaultPropertiesRedundancySettingsArgs',
+    'VaultPropertiesArgs',
+]
+
+@pulumi.input_type
+class AzureMonitorAlertSettingsArgs:
+    def __init__(__self__, *,
+                 alerts_for_all_failover_issues: Optional[pulumi.Input[Union[str, 'AlertsState']]] = None,
+                 alerts_for_all_job_failures: Optional[pulumi.Input[Union[str, 'AlertsState']]] = None,
+                 alerts_for_all_replication_issues: Optional[pulumi.Input[Union[str, 'AlertsState']]] = None):
+        """
+        Settings for Azure Monitor based alerts
+        """
+        if alerts_for_all_failover_issues is not None:
+            pulumi.set(__self__, "alerts_for_all_failover_issues", alerts_for_all_failover_issues)
+        if alerts_for_all_job_failures is not None:
+            pulumi.set(__self__, "alerts_for_all_job_failures", alerts_for_all_job_failures)
+        if alerts_for_all_replication_issues is not None:
+            pulumi.set(__self__, "alerts_for_all_replication_issues", alerts_for_all_replication_issues)
+
+    @property
+    @pulumi.getter(name="alertsForAllFailoverIssues")
+    def alerts_for_all_failover_issues(self) -> Optional[pulumi.Input[Union[str, 'AlertsState']]]:
+        return pulumi.get(self, "alerts_for_all_failover_issues")
+
+    @alerts_for_all_failover_issues.setter
+    def alerts_for_all_failover_issues(self, value: Optional[pulumi.Input[Union[str, 'AlertsState']]]):
+        pulumi.set(self, "alerts_for_all_failover_issues", value)
+
+    @property
+    @pulumi.getter(name="alertsForAllJobFailures")
+    def alerts_for_all_job_failures(self) -> Optional[pulumi.Input[Union[str, 'AlertsState']]]:
+        return pulumi.get(self, "alerts_for_all_job_failures")
+
+    @alerts_for_all_job_failures.setter
+    def alerts_for_all_job_failures(self, value: Optional[pulumi.Input[Union[str, 'AlertsState']]]):
+        pulumi.set(self, "alerts_for_all_job_failures", value)
+
+    @property
+    @pulumi.getter(name="alertsForAllReplicationIssues")
+    def alerts_for_all_replication_issues(self) -> Optional[pulumi.Input[Union[str, 'AlertsState']]]:
+        return pulumi.get(self, "alerts_for_all_replication_issues")
+
+    @alerts_for_all_replication_issues.setter
+    def alerts_for_all_replication_issues(self, value: Optional[pulumi.Input[Union[str, 'AlertsState']]]):
+        pulumi.set(self, "alerts_for_all_replication_issues", value)
+
+
+@pulumi.input_type
+class ClassicAlertSettingsArgs:
+    def __init__(__self__, *,
+                 alerts_for_critical_operations: Optional[pulumi.Input[Union[str, 'AlertsState']]] = None,
+                 email_notifications_for_site_recovery: Optional[pulumi.Input[Union[str, 'AlertsState']]] = None):
+        """
+        Settings for classic alerts
+        """
+        if alerts_for_critical_operations is not None:
+            pulumi.set(__self__, "alerts_for_critical_operations", alerts_for_critical_operations)
+        if email_notifications_for_site_recovery is not None:
+            pulumi.set(__self__, "email_notifications_for_site_recovery", email_notifications_for_site_recovery)
+
+    @property
+    @pulumi.getter(name="alertsForCriticalOperations")
+    def alerts_for_critical_operations(self) -> Optional[pulumi.Input[Union[str, 'AlertsState']]]:
+        return pulumi.get(self, "alerts_for_critical_operations")
+
+    @alerts_for_critical_operations.setter
+    def alerts_for_critical_operations(self, value: Optional[pulumi.Input[Union[str, 'AlertsState']]]):
+        pulumi.set(self, "alerts_for_critical_operations", value)
+
+    @property
+    @pulumi.getter(name="emailNotificationsForSiteRecovery")
+    def email_notifications_for_site_recovery(self) -> Optional[pulumi.Input[Union[str, 'AlertsState']]]:
+        return pulumi.get(self, "email_notifications_for_site_recovery")
+
+    @email_notifications_for_site_recovery.setter
+    def email_notifications_for_site_recovery(self, value: Optional[pulumi.Input[Union[str, 'AlertsState']]]):
+        pulumi.set(self, "email_notifications_for_site_recovery", value)
+
+
+@pulumi.input_type
+class CmkKekIdentityArgs:
+    def __init__(__self__, *,
+                 use_system_assigned_identity: Optional[pulumi.Input[bool]] = None,
+                 user_assigned_identity: Optional[pulumi.Input[str]] = None):
+        """
+        The details of the identity used for CMK
+        :param pulumi.Input[bool] use_system_assigned_identity: Indicate that system assigned identity should be used. Mutually exclusive with 'userAssignedIdentity' field
+        :param pulumi.Input[str] user_assigned_identity: The user assigned identity to be used to grant permissions in case the type of identity used is UserAssigned
+        """
+        if use_system_assigned_identity is not None:
+            pulumi.set(__self__, "use_system_assigned_identity", use_system_assigned_identity)
+        if user_assigned_identity is not None:
+            pulumi.set(__self__, "user_assigned_identity", user_assigned_identity)
+
+    @property
+    @pulumi.getter(name="useSystemAssignedIdentity")
+    def use_system_assigned_identity(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Indicate that system assigned identity should be used. Mutually exclusive with 'userAssignedIdentity' field
+        """
+        return pulumi.get(self, "use_system_assigned_identity")
+
+    @use_system_assigned_identity.setter
+    def use_system_assigned_identity(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "use_system_assigned_identity", value)
+
+    @property
+    @pulumi.getter(name="userAssignedIdentity")
+    def user_assigned_identity(self) -> Optional[pulumi.Input[str]]:
+        """
+        The user assigned identity to be used to grant permissions in case the type of identity used is UserAssigned
+        """
+        return pulumi.get(self, "user_assigned_identity")
+
+    @user_assigned_identity.setter
+    def user_assigned_identity(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "user_assigned_identity", value)
+
+
+@pulumi.input_type
+class CmkKeyVaultPropertiesArgs:
+    def __init__(__self__, *,
+                 key_uri: Optional[pulumi.Input[str]] = None):
+        """
+        The properties of the Key Vault which hosts CMK
+        :param pulumi.Input[str] key_uri: The key uri of the Customer Managed Key
+        """
+        if key_uri is not None:
+            pulumi.set(__self__, "key_uri", key_uri)
+
+    @property
+    @pulumi.getter(name="keyUri")
+    def key_uri(self) -> Optional[pulumi.Input[str]]:
+        """
+        The key uri of the Customer Managed Key
+        """
+        return pulumi.get(self, "key_uri")
+
+    @key_uri.setter
+    def key_uri(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "key_uri", value)
+
+
+@pulumi.input_type
+class CrossSubscriptionRestoreSettingsArgs:
+    def __init__(__self__, *,
+                 cross_subscription_restore_state: Optional[pulumi.Input[Union[str, 'CrossSubscriptionRestoreState']]] = None):
+        """
+        Settings for Cross Subscription Restore Settings
+        """
+        if cross_subscription_restore_state is not None:
+            pulumi.set(__self__, "cross_subscription_restore_state", cross_subscription_restore_state)
+
+    @property
+    @pulumi.getter(name="crossSubscriptionRestoreState")
+    def cross_subscription_restore_state(self) -> Optional[pulumi.Input[Union[str, 'CrossSubscriptionRestoreState']]]:
+        return pulumi.get(self, "cross_subscription_restore_state")
+
+    @cross_subscription_restore_state.setter
+    def cross_subscription_restore_state(self, value: Optional[pulumi.Input[Union[str, 'CrossSubscriptionRestoreState']]]):
+        pulumi.set(self, "cross_subscription_restore_state", value)
+
+
+@pulumi.input_type
+class IdentityDataArgs:
+    def __init__(__self__, *,
+                 type: pulumi.Input[Union[str, 'ResourceIdentityType']],
+                 user_assigned_identities: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        Identity for the resource.
+        :param pulumi.Input[Union[str, 'ResourceIdentityType']] type: The type of managed identity used. The type 'SystemAssigned, UserAssigned' includes both an implicitly created identity and a set of user-assigned identities. The type 'None' will remove any identities.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] user_assigned_identities: The list of user-assigned identities associated with the resource. The user-assigned identity dictionary keys will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
+        """
+        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) -> pulumi.Input[Union[str, 'ResourceIdentityType']]:
+        """
+        The type of managed identity used. The type 'SystemAssigned, UserAssigned' includes both an implicitly created identity and a set of user-assigned identities. The type 'None' will remove any identities.
+        """
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: pulumi.Input[Union[str, 'ResourceIdentityType']]):
+        pulumi.set(self, "type", value)
+
+    @property
+    @pulumi.getter(name="userAssignedIdentities")
+    def user_assigned_identities(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        The list of user-assigned identities associated with the resource. The user-assigned identity dictionary keys will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
+        """
+        return pulumi.get(self, "user_assigned_identities")
+
+    @user_assigned_identities.setter
+    def user_assigned_identities(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "user_assigned_identities", value)
+
+
+@pulumi.input_type
+class ImmutabilitySettingsArgs:
+    def __init__(__self__, *,
+                 state: Optional[pulumi.Input[Union[str, 'ImmutabilityState']]] = None):
+        """
+        Immutability Settings of vault
+        """
+        if state is not None:
+            pulumi.set(__self__, "state", state)
+
+    @property
+    @pulumi.getter
+    def state(self) -> Optional[pulumi.Input[Union[str, 'ImmutabilityState']]]:
+        return pulumi.get(self, "state")
+
+    @state.setter
+    def state(self, value: Optional[pulumi.Input[Union[str, 'ImmutabilityState']]]):
+        pulumi.set(self, "state", value)
+
+
+@pulumi.input_type
+class MonitoringSettingsArgs:
+    def __init__(__self__, *,
+                 azure_monitor_alert_settings: Optional[pulumi.Input['AzureMonitorAlertSettingsArgs']] = None,
+                 classic_alert_settings: Optional[pulumi.Input['ClassicAlertSettingsArgs']] = None):
+        """
+        Monitoring Settings of the vault
+        :param pulumi.Input['AzureMonitorAlertSettingsArgs'] azure_monitor_alert_settings: Settings for Azure Monitor based alerts
+        :param pulumi.Input['ClassicAlertSettingsArgs'] classic_alert_settings: Settings for classic alerts
+        """
+        if azure_monitor_alert_settings is not None:
+            pulumi.set(__self__, "azure_monitor_alert_settings", azure_monitor_alert_settings)
+        if classic_alert_settings is not None:
+            pulumi.set(__self__, "classic_alert_settings", classic_alert_settings)
+
+    @property
+    @pulumi.getter(name="azureMonitorAlertSettings")
+    def azure_monitor_alert_settings(self) -> Optional[pulumi.Input['AzureMonitorAlertSettingsArgs']]:
+        """
+        Settings for Azure Monitor based alerts
+        """
+        return pulumi.get(self, "azure_monitor_alert_settings")
+
+    @azure_monitor_alert_settings.setter
+    def azure_monitor_alert_settings(self, value: Optional[pulumi.Input['AzureMonitorAlertSettingsArgs']]):
+        pulumi.set(self, "azure_monitor_alert_settings", value)
+
+    @property
+    @pulumi.getter(name="classicAlertSettings")
+    def classic_alert_settings(self) -> Optional[pulumi.Input['ClassicAlertSettingsArgs']]:
+        """
+        Settings for classic alerts
+        """
+        return pulumi.get(self, "classic_alert_settings")
+
+    @classic_alert_settings.setter
+    def classic_alert_settings(self, value: Optional[pulumi.Input['ClassicAlertSettingsArgs']]):
+        pulumi.set(self, "classic_alert_settings", value)
+
+
+@pulumi.input_type
+class RestoreSettingsArgs:
+    def __init__(__self__, *,
+                 cross_subscription_restore_settings: Optional[pulumi.Input['CrossSubscriptionRestoreSettingsArgs']] = None):
+        """
+        Restore Settings  of the vault
+        :param pulumi.Input['CrossSubscriptionRestoreSettingsArgs'] cross_subscription_restore_settings: Settings for CrossSubscriptionRestore
+        """
+        if cross_subscription_restore_settings is not None:
+            pulumi.set(__self__, "cross_subscription_restore_settings", cross_subscription_restore_settings)
+
+    @property
+    @pulumi.getter(name="crossSubscriptionRestoreSettings")
+    def cross_subscription_restore_settings(self) -> Optional[pulumi.Input['CrossSubscriptionRestoreSettingsArgs']]:
+        """
+        Settings for CrossSubscriptionRestore
+        """
+        return pulumi.get(self, "cross_subscription_restore_settings")
+
+    @cross_subscription_restore_settings.setter
+    def cross_subscription_restore_settings(self, value: Optional[pulumi.Input['CrossSubscriptionRestoreSettingsArgs']]):
+        pulumi.set(self, "cross_subscription_restore_settings", value)
+
+
+@pulumi.input_type
+class SecuritySettingsArgs:
+    def __init__(__self__, *,
+                 immutability_settings: Optional[pulumi.Input['ImmutabilitySettingsArgs']] = None,
+                 soft_delete_settings: Optional[pulumi.Input['SoftDeleteSettingsArgs']] = None):
+        """
+        Security Settings of the vault
+        :param pulumi.Input['ImmutabilitySettingsArgs'] immutability_settings: Immutability Settings of a vault
+        :param pulumi.Input['SoftDeleteSettingsArgs'] soft_delete_settings: Soft delete Settings of a vault
+        """
+        if immutability_settings is not None:
+            pulumi.set(__self__, "immutability_settings", immutability_settings)
+        if soft_delete_settings is not None:
+            pulumi.set(__self__, "soft_delete_settings", soft_delete_settings)
+
+    @property
+    @pulumi.getter(name="immutabilitySettings")
+    def immutability_settings(self) -> Optional[pulumi.Input['ImmutabilitySettingsArgs']]:
+        """
+        Immutability Settings of a vault
+        """
+        return pulumi.get(self, "immutability_settings")
+
+    @immutability_settings.setter
+    def immutability_settings(self, value: Optional[pulumi.Input['ImmutabilitySettingsArgs']]):
+        pulumi.set(self, "immutability_settings", value)
+
+    @property
+    @pulumi.getter(name="softDeleteSettings")
+    def soft_delete_settings(self) -> Optional[pulumi.Input['SoftDeleteSettingsArgs']]:
+        """
+        Soft delete Settings of a vault
+        """
+        return pulumi.get(self, "soft_delete_settings")
+
+    @soft_delete_settings.setter
+    def soft_delete_settings(self, value: Optional[pulumi.Input['SoftDeleteSettingsArgs']]):
+        pulumi.set(self, "soft_delete_settings", value)
+
+
+@pulumi.input_type
+class SkuArgs:
+    def __init__(__self__, *,
+                 name: pulumi.Input[Union[str, 'SkuName']],
+                 capacity: Optional[pulumi.Input[str]] = None,
+                 family: Optional[pulumi.Input[str]] = None,
+                 size: Optional[pulumi.Input[str]] = None,
+                 tier: Optional[pulumi.Input[str]] = None):
+        """
+        Identifies the unique system identifier for each Azure resource.
+        :param pulumi.Input[Union[str, 'SkuName']] name: Name of SKU is RS0 (Recovery Services 0th version) and the tier is standard tier. They do not have affect on backend storage redundancy or any other vault settings. To manage storage redundancy, use the backupstorageconfig
+        :param pulumi.Input[str] capacity: The sku capacity
+        :param pulumi.Input[str] family: The sku family
+        :param pulumi.Input[str] size: The sku size
+        :param pulumi.Input[str] tier: The Sku tier.
+        """
+        pulumi.set(__self__, "name", name)
+        if capacity is not None:
+            pulumi.set(__self__, "capacity", capacity)
+        if family is not None:
+            pulumi.set(__self__, "family", family)
+        if size is not None:
+            pulumi.set(__self__, "size", size)
+        if tier is not None:
+            pulumi.set(__self__, "tier", tier)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[Union[str, 'SkuName']]:
+        """
+        Name of SKU is RS0 (Recovery Services 0th version) and the tier is standard tier. They do not have affect on backend storage redundancy or any other vault settings. To manage storage redundancy, use the backupstorageconfig
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[Union[str, 'SkuName']]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def capacity(self) -> Optional[pulumi.Input[str]]:
+        """
+        The sku capacity
+        """
+        return pulumi.get(self, "capacity")
+
+    @capacity.setter
+    def capacity(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "capacity", value)
+
+    @property
+    @pulumi.getter
+    def family(self) -> Optional[pulumi.Input[str]]:
+        """
+        The sku family
+        """
+        return pulumi.get(self, "family")
+
+    @family.setter
+    def family(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "family", value)
+
+    @property
+    @pulumi.getter
+    def size(self) -> Optional[pulumi.Input[str]]:
+        """
+        The sku size
+        """
+        return pulumi.get(self, "size")
+
+    @size.setter
+    def size(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "size", value)
+
+    @property
+    @pulumi.getter
+    def tier(self) -> Optional[pulumi.Input[str]]:
+        """
+        The Sku tier.
+        """
+        return pulumi.get(self, "tier")
+
+    @tier.setter
+    def tier(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "tier", value)
+
+
+@pulumi.input_type
+class SoftDeleteSettingsArgs:
+    def __init__(__self__, *,
+                 enhanced_security_state: Optional[pulumi.Input[Union[str, 'EnhancedSecurityState']]] = None,
+                 soft_delete_retention_period_in_days: Optional[pulumi.Input[int]] = None,
+                 soft_delete_state: Optional[pulumi.Input[Union[str, 'SoftDeleteState']]] = None):
+        """
+        Soft delete Settings of vault
+        :param pulumi.Input[int] soft_delete_retention_period_in_days: Soft delete retention period in days
+        """
+        if enhanced_security_state is not None:
+            pulumi.set(__self__, "enhanced_security_state", enhanced_security_state)
+        if soft_delete_retention_period_in_days is not None:
+            pulumi.set(__self__, "soft_delete_retention_period_in_days", soft_delete_retention_period_in_days)
+        if soft_delete_state is not None:
+            pulumi.set(__self__, "soft_delete_state", soft_delete_state)
+
+    @property
+    @pulumi.getter(name="enhancedSecurityState")
+    def enhanced_security_state(self) -> Optional[pulumi.Input[Union[str, 'EnhancedSecurityState']]]:
+        return pulumi.get(self, "enhanced_security_state")
+
+    @enhanced_security_state.setter
+    def enhanced_security_state(self, value: Optional[pulumi.Input[Union[str, 'EnhancedSecurityState']]]):
+        pulumi.set(self, "enhanced_security_state", value)
+
+    @property
+    @pulumi.getter(name="softDeleteRetentionPeriodInDays")
+    def soft_delete_retention_period_in_days(self) -> Optional[pulumi.Input[int]]:
+        """
+        Soft delete retention period in days
+        """
+        return pulumi.get(self, "soft_delete_retention_period_in_days")
+
+    @soft_delete_retention_period_in_days.setter
+    def soft_delete_retention_period_in_days(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "soft_delete_retention_period_in_days", value)
+
+    @property
+    @pulumi.getter(name="softDeleteState")
+    def soft_delete_state(self) -> Optional[pulumi.Input[Union[str, 'SoftDeleteState']]]:
+        return pulumi.get(self, "soft_delete_state")
+
+    @soft_delete_state.setter
+    def soft_delete_state(self, value: Optional[pulumi.Input[Union[str, 'SoftDeleteState']]]):
+        pulumi.set(self, "soft_delete_state", value)
+
+
+@pulumi.input_type
+class VaultPropertiesEncryptionArgs:
+    def __init__(__self__, *,
+                 infrastructure_encryption: Optional[pulumi.Input[Union[str, 'InfrastructureEncryptionState']]] = None,
+                 kek_identity: Optional[pulumi.Input['CmkKekIdentityArgs']] = None,
+                 key_vault_properties: Optional[pulumi.Input['CmkKeyVaultPropertiesArgs']] = None):
+        """
+        Customer Managed Key details of the resource.
+        :param pulumi.Input[Union[str, 'InfrastructureEncryptionState']] infrastructure_encryption: Enabling/Disabling the Double Encryption state
+        :param pulumi.Input['CmkKekIdentityArgs'] kek_identity: The details of the identity used for CMK
+        :param pulumi.Input['CmkKeyVaultPropertiesArgs'] key_vault_properties: The properties of the Key Vault which hosts CMK
+        """
+        if infrastructure_encryption is not None:
+            pulumi.set(__self__, "infrastructure_encryption", infrastructure_encryption)
+        if kek_identity is not None:
+            pulumi.set(__self__, "kek_identity", kek_identity)
+        if key_vault_properties is not None:
+            pulumi.set(__self__, "key_vault_properties", key_vault_properties)
+
+    @property
+    @pulumi.getter(name="infrastructureEncryption")
+    def infrastructure_encryption(self) -> Optional[pulumi.Input[Union[str, 'InfrastructureEncryptionState']]]:
+        """
+        Enabling/Disabling the Double Encryption state
+        """
+        return pulumi.get(self, "infrastructure_encryption")
+
+    @infrastructure_encryption.setter
+    def infrastructure_encryption(self, value: Optional[pulumi.Input[Union[str, 'InfrastructureEncryptionState']]]):
+        pulumi.set(self, "infrastructure_encryption", value)
+
+    @property
+    @pulumi.getter(name="kekIdentity")
+    def kek_identity(self) -> Optional[pulumi.Input['CmkKekIdentityArgs']]:
+        """
+        The details of the identity used for CMK
+        """
+        return pulumi.get(self, "kek_identity")
+
+    @kek_identity.setter
+    def kek_identity(self, value: Optional[pulumi.Input['CmkKekIdentityArgs']]):
+        pulumi.set(self, "kek_identity", value)
+
+    @property
+    @pulumi.getter(name="keyVaultProperties")
+    def key_vault_properties(self) -> Optional[pulumi.Input['CmkKeyVaultPropertiesArgs']]:
+        """
+        The properties of the Key Vault which hosts CMK
+        """
+        return pulumi.get(self, "key_vault_properties")
+
+    @key_vault_properties.setter
+    def key_vault_properties(self, value: Optional[pulumi.Input['CmkKeyVaultPropertiesArgs']]):
+        pulumi.set(self, "key_vault_properties", value)
+
+
+@pulumi.input_type
+class VaultPropertiesRedundancySettingsArgs:
+    def __init__(__self__, *,
+                 cross_region_restore: Optional[pulumi.Input[Union[str, 'CrossRegionRestore']]] = None,
+                 standard_tier_storage_redundancy: Optional[pulumi.Input[Union[str, 'StandardTierStorageRedundancy']]] = None):
+        """
+        The redundancy Settings of a Vault
+        :param pulumi.Input[Union[str, 'CrossRegionRestore']] cross_region_restore: Flag to show if Cross Region Restore is enabled on the Vault or not
+        :param pulumi.Input[Union[str, 'StandardTierStorageRedundancy']] standard_tier_storage_redundancy: The storage redundancy setting of a vault
+        """
+        if cross_region_restore is not None:
+            pulumi.set(__self__, "cross_region_restore", cross_region_restore)
+        if standard_tier_storage_redundancy is not None:
+            pulumi.set(__self__, "standard_tier_storage_redundancy", standard_tier_storage_redundancy)
+
+    @property
+    @pulumi.getter(name="crossRegionRestore")
+    def cross_region_restore(self) -> Optional[pulumi.Input[Union[str, 'CrossRegionRestore']]]:
+        """
+        Flag to show if Cross Region Restore is enabled on the Vault or not
+        """
+        return pulumi.get(self, "cross_region_restore")
+
+    @cross_region_restore.setter
+    def cross_region_restore(self, value: Optional[pulumi.Input[Union[str, 'CrossRegionRestore']]]):
+        pulumi.set(self, "cross_region_restore", value)
+
+    @property
+    @pulumi.getter(name="standardTierStorageRedundancy")
+    def standard_tier_storage_redundancy(self) -> Optional[pulumi.Input[Union[str, 'StandardTierStorageRedundancy']]]:
+        """
+        The storage redundancy setting of a vault
+        """
+        return pulumi.get(self, "standard_tier_storage_redundancy")
+
+    @standard_tier_storage_redundancy.setter
+    def standard_tier_storage_redundancy(self, value: Optional[pulumi.Input[Union[str, 'StandardTierStorageRedundancy']]]):
+        pulumi.set(self, "standard_tier_storage_redundancy", value)
+
+
+@pulumi.input_type
+class VaultPropertiesArgs:
+    def __init__(__self__, *,
+                 encryption: Optional[pulumi.Input['VaultPropertiesEncryptionArgs']] = None,
+                 monitoring_settings: Optional[pulumi.Input['MonitoringSettingsArgs']] = None,
+                 public_network_access: Optional[pulumi.Input[Union[str, 'PublicNetworkAccess']]] = None,
+                 redundancy_settings: Optional[pulumi.Input['VaultPropertiesRedundancySettingsArgs']] = None,
+                 restore_settings: Optional[pulumi.Input['RestoreSettingsArgs']] = None,
+                 security_settings: Optional[pulumi.Input['SecuritySettingsArgs']] = None):
+        """
+        Properties of the vault.
+        :param pulumi.Input['VaultPropertiesEncryptionArgs'] encryption: Customer Managed Key details of the resource.
+        :param pulumi.Input['MonitoringSettingsArgs'] monitoring_settings: Monitoring Settings of the vault
+        :param pulumi.Input[Union[str, 'PublicNetworkAccess']] public_network_access: property to enable or disable resource provider inbound network traffic from public clients
+        :param pulumi.Input['VaultPropertiesRedundancySettingsArgs'] redundancy_settings: The redundancy Settings of a Vault
+        :param pulumi.Input['RestoreSettingsArgs'] restore_settings: Restore Settings of the vault
+        :param pulumi.Input['SecuritySettingsArgs'] security_settings: Security Settings of the vault
+        """
+        if encryption is not None:
+            pulumi.set(__self__, "encryption", encryption)
+        if monitoring_settings is not None:
+            pulumi.set(__self__, "monitoring_settings", monitoring_settings)
+        if public_network_access is not None:
+            pulumi.set(__self__, "public_network_access", public_network_access)
+        if redundancy_settings is not None:
+            pulumi.set(__self__, "redundancy_settings", redundancy_settings)
+        if restore_settings is not None:
+            pulumi.set(__self__, "restore_settings", restore_settings)
+        if security_settings is not None:
+            pulumi.set(__self__, "security_settings", security_settings)
+
+    @property
+    @pulumi.getter
+    def encryption(self) -> Optional[pulumi.Input['VaultPropertiesEncryptionArgs']]:
+        """
+        Customer Managed Key details of the resource.
+        """
+        return pulumi.get(self, "encryption")
+
+    @encryption.setter
+    def encryption(self, value: Optional[pulumi.Input['VaultPropertiesEncryptionArgs']]):
+        pulumi.set(self, "encryption", value)
+
+    @property
+    @pulumi.getter(name="monitoringSettings")
+    def monitoring_settings(self) -> Optional[pulumi.Input['MonitoringSettingsArgs']]:
+        """
+        Monitoring Settings of the vault
+        """
+        return pulumi.get(self, "monitoring_settings")
+
+    @monitoring_settings.setter
+    def monitoring_settings(self, value: Optional[pulumi.Input['MonitoringSettingsArgs']]):
+        pulumi.set(self, "monitoring_settings", value)
+
+    @property
+    @pulumi.getter(name="publicNetworkAccess")
+    def public_network_access(self) -> Optional[pulumi.Input[Union[str, 'PublicNetworkAccess']]]:
+        """
+        property to enable or disable resource provider inbound network traffic from public clients
+        """
+        return pulumi.get(self, "public_network_access")
+
+    @public_network_access.setter
+    def public_network_access(self, value: Optional[pulumi.Input[Union[str, 'PublicNetworkAccess']]]):
+        pulumi.set(self, "public_network_access", value)
+
+    @property
+    @pulumi.getter(name="redundancySettings")
+    def redundancy_settings(self) -> Optional[pulumi.Input['VaultPropertiesRedundancySettingsArgs']]:
+        """
+        The redundancy Settings of a Vault
+        """
+        return pulumi.get(self, "redundancy_settings")
+
+    @redundancy_settings.setter
+    def redundancy_settings(self, value: Optional[pulumi.Input['VaultPropertiesRedundancySettingsArgs']]):
+        pulumi.set(self, "redundancy_settings", value)
+
+    @property
+    @pulumi.getter(name="restoreSettings")
+    def restore_settings(self) -> Optional[pulumi.Input['RestoreSettingsArgs']]:
+        """
+        Restore Settings of the vault
+        """
+        return pulumi.get(self, "restore_settings")
+
+    @restore_settings.setter
+    def restore_settings(self, value: Optional[pulumi.Input['RestoreSettingsArgs']]):
+        pulumi.set(self, "restore_settings", value)
+
+    @property
+    @pulumi.getter(name="securitySettings")
+    def security_settings(self) -> Optional[pulumi.Input['SecuritySettingsArgs']]:
+        """
+        Security Settings of the vault
+        """
+        return pulumi.get(self, "security_settings")
+
+    @security_settings.setter
+    def security_settings(self, value: Optional[pulumi.Input['SecuritySettingsArgs']]):
+        pulumi.set(self, "security_settings", value)
+
+