pulumi-azure-native 2.50.0a1720550655__py3-none-any.whl → 2.50.1__py3-none-any.whl

pulumi_azure_native/servicebus/v20230101preview/_inputs.py

@@ -0,0 +1,1285 @@
+# 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 sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from ... import _utilities
+from ._enums import *
+
+__all__ = [
+    'ActionArgs',
+    'ActionArgsDict',
+    'ConnectionStateArgs',
+    'ConnectionStateArgsDict',
+    'CorrelationFilterArgs',
+    'CorrelationFilterArgsDict',
+    'EncryptionArgs',
+    'EncryptionArgsDict',
+    'GeoDataReplicationPropertiesArgs',
+    'GeoDataReplicationPropertiesArgsDict',
+    'IdentityArgs',
+    'IdentityArgsDict',
+    'KeyVaultPropertiesArgs',
+    'KeyVaultPropertiesArgsDict',
+    'NWRuleSetIpRulesArgs',
+    'NWRuleSetIpRulesArgsDict',
+    'NWRuleSetVirtualNetworkRulesArgs',
+    'NWRuleSetVirtualNetworkRulesArgsDict',
+    'NamespaceReplicaLocationArgs',
+    'NamespaceReplicaLocationArgsDict',
+    'PrivateEndpointConnectionArgs',
+    'PrivateEndpointConnectionArgsDict',
+    'PrivateEndpointArgs',
+    'PrivateEndpointArgsDict',
+    'SBClientAffinePropertiesArgs',
+    'SBClientAffinePropertiesArgsDict',
+    'SBSkuArgs',
+    'SBSkuArgsDict',
+    'SqlFilterArgs',
+    'SqlFilterArgsDict',
+    'SubnetArgs',
+    'SubnetArgsDict',
+    'UserAssignedIdentityPropertiesArgs',
+    'UserAssignedIdentityPropertiesArgsDict',
+]
+
+MYPY = False
+
+if not MYPY:
+    class ActionArgsDict(TypedDict):
+        """
+        Represents the filter actions which are allowed for the transformation of a message that have been matched by a filter expression.
+        """
+        compatibility_level: NotRequired[pulumi.Input[int]]
+        """
+        This property is reserved for future use. An integer value showing the compatibility level, currently hard-coded to 20.
+        """
+        requires_preprocessing: NotRequired[pulumi.Input[bool]]
+        """
+        Value that indicates whether the rule action requires preprocessing.
+        """
+        sql_expression: NotRequired[pulumi.Input[str]]
+        """
+        SQL expression. e.g. MyProperty='ABC'
+        """
+elif False:
+    ActionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ActionArgs:
+    def __init__(__self__, *,
+                 compatibility_level: Optional[pulumi.Input[int]] = None,
+                 requires_preprocessing: Optional[pulumi.Input[bool]] = None,
+                 sql_expression: Optional[pulumi.Input[str]] = None):
+        """
+        Represents the filter actions which are allowed for the transformation of a message that have been matched by a filter expression.
+        :param pulumi.Input[int] compatibility_level: This property is reserved for future use. An integer value showing the compatibility level, currently hard-coded to 20.
+        :param pulumi.Input[bool] requires_preprocessing: Value that indicates whether the rule action requires preprocessing.
+        :param pulumi.Input[str] sql_expression: SQL expression. e.g. MyProperty='ABC'
+        """
+        if compatibility_level is not None:
+            pulumi.set(__self__, "compatibility_level", compatibility_level)
+        if requires_preprocessing is None:
+            requires_preprocessing = True
+        if requires_preprocessing is not None:
+            pulumi.set(__self__, "requires_preprocessing", requires_preprocessing)
+        if sql_expression is not None:
+            pulumi.set(__self__, "sql_expression", sql_expression)
+
+    @property
+    @pulumi.getter(name="compatibilityLevel")
+    def compatibility_level(self) -> Optional[pulumi.Input[int]]:
+        """
+        This property is reserved for future use. An integer value showing the compatibility level, currently hard-coded to 20.
+        """
+        return pulumi.get(self, "compatibility_level")
+
+    @compatibility_level.setter
+    def compatibility_level(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "compatibility_level", value)
+
+    @property
+    @pulumi.getter(name="requiresPreprocessing")
+    def requires_preprocessing(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Value that indicates whether the rule action requires preprocessing.
+        """
+        return pulumi.get(self, "requires_preprocessing")
+
+    @requires_preprocessing.setter
+    def requires_preprocessing(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "requires_preprocessing", value)
+
+    @property
+    @pulumi.getter(name="sqlExpression")
+    def sql_expression(self) -> Optional[pulumi.Input[str]]:
+        """
+        SQL expression. e.g. MyProperty='ABC'
+        """
+        return pulumi.get(self, "sql_expression")
+
+    @sql_expression.setter
+    def sql_expression(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "sql_expression", value)
+
+
+if not MYPY:
+    class ConnectionStateArgsDict(TypedDict):
+        """
+        ConnectionState information.
+        """
+        description: NotRequired[pulumi.Input[str]]
+        """
+        Description of the connection state.
+        """
+        status: NotRequired[pulumi.Input[Union[str, 'PrivateLinkConnectionStatus']]]
+        """
+        Status of the connection.
+        """
+elif False:
+    ConnectionStateArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ConnectionStateArgs:
+    def __init__(__self__, *,
+                 description: Optional[pulumi.Input[str]] = None,
+                 status: Optional[pulumi.Input[Union[str, 'PrivateLinkConnectionStatus']]] = None):
+        """
+        ConnectionState information.
+        :param pulumi.Input[str] description: Description of the connection state.
+        :param pulumi.Input[Union[str, 'PrivateLinkConnectionStatus']] status: Status of the connection.
+        """
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[pulumi.Input[str]]:
+        """
+        Description of the connection state.
+        """
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "description", value)
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[pulumi.Input[Union[str, 'PrivateLinkConnectionStatus']]]:
+        """
+        Status of the connection.
+        """
+        return pulumi.get(self, "status")
+
+    @status.setter
+    def status(self, value: Optional[pulumi.Input[Union[str, 'PrivateLinkConnectionStatus']]]):
+        pulumi.set(self, "status", value)
+
+
+if not MYPY:
+    class CorrelationFilterArgsDict(TypedDict):
+        """
+        Represents the correlation filter expression.
+        """
+        content_type: NotRequired[pulumi.Input[str]]
+        """
+        Content type of the message.
+        """
+        correlation_id: NotRequired[pulumi.Input[str]]
+        """
+        Identifier of the correlation.
+        """
+        label: NotRequired[pulumi.Input[str]]
+        """
+        Application specific label.
+        """
+        message_id: NotRequired[pulumi.Input[str]]
+        """
+        Identifier of the message.
+        """
+        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        dictionary object for custom filters
+        """
+        reply_to: NotRequired[pulumi.Input[str]]
+        """
+        Address of the queue to reply to.
+        """
+        reply_to_session_id: NotRequired[pulumi.Input[str]]
+        """
+        Session identifier to reply to.
+        """
+        requires_preprocessing: NotRequired[pulumi.Input[bool]]
+        """
+        Value that indicates whether the rule action requires preprocessing.
+        """
+        session_id: NotRequired[pulumi.Input[str]]
+        """
+        Session identifier.
+        """
+        to: NotRequired[pulumi.Input[str]]
+        """
+        Address to send to.
+        """
+elif False:
+    CorrelationFilterArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class CorrelationFilterArgs:
+    def __init__(__self__, *,
+                 content_type: Optional[pulumi.Input[str]] = None,
+                 correlation_id: Optional[pulumi.Input[str]] = None,
+                 label: Optional[pulumi.Input[str]] = None,
+                 message_id: Optional[pulumi.Input[str]] = None,
+                 properties: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 reply_to: Optional[pulumi.Input[str]] = None,
+                 reply_to_session_id: Optional[pulumi.Input[str]] = None,
+                 requires_preprocessing: Optional[pulumi.Input[bool]] = None,
+                 session_id: Optional[pulumi.Input[str]] = None,
+                 to: Optional[pulumi.Input[str]] = None):
+        """
+        Represents the correlation filter expression.
+        :param pulumi.Input[str] content_type: Content type of the message.
+        :param pulumi.Input[str] correlation_id: Identifier of the correlation.
+        :param pulumi.Input[str] label: Application specific label.
+        :param pulumi.Input[str] message_id: Identifier of the message.
+        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] properties: dictionary object for custom filters
+        :param pulumi.Input[str] reply_to: Address of the queue to reply to.
+        :param pulumi.Input[str] reply_to_session_id: Session identifier to reply to.
+        :param pulumi.Input[bool] requires_preprocessing: Value that indicates whether the rule action requires preprocessing.
+        :param pulumi.Input[str] session_id: Session identifier.
+        :param pulumi.Input[str] to: Address to send to.
+        """
+        if content_type is not None:
+            pulumi.set(__self__, "content_type", content_type)
+        if correlation_id is not None:
+            pulumi.set(__self__, "correlation_id", correlation_id)
+        if label is not None:
+            pulumi.set(__self__, "label", label)
+        if message_id is not None:
+            pulumi.set(__self__, "message_id", message_id)
+        if properties is not None:
+            pulumi.set(__self__, "properties", properties)
+        if reply_to is not None:
+            pulumi.set(__self__, "reply_to", reply_to)
+        if reply_to_session_id is not None:
+            pulumi.set(__self__, "reply_to_session_id", reply_to_session_id)
+        if requires_preprocessing is None:
+            requires_preprocessing = True
+        if requires_preprocessing is not None:
+            pulumi.set(__self__, "requires_preprocessing", requires_preprocessing)
+        if session_id is not None:
+            pulumi.set(__self__, "session_id", session_id)
+        if to is not None:
+            pulumi.set(__self__, "to", to)
+
+    @property
+    @pulumi.getter(name="contentType")
+    def content_type(self) -> Optional[pulumi.Input[str]]:
+        """
+        Content type of the message.
+        """
+        return pulumi.get(self, "content_type")
+
+    @content_type.setter
+    def content_type(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "content_type", value)
+
+    @property
+    @pulumi.getter(name="correlationId")
+    def correlation_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        Identifier of the correlation.
+        """
+        return pulumi.get(self, "correlation_id")
+
+    @correlation_id.setter
+    def correlation_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "correlation_id", value)
+
+    @property
+    @pulumi.getter
+    def label(self) -> Optional[pulumi.Input[str]]:
+        """
+        Application specific label.
+        """
+        return pulumi.get(self, "label")
+
+    @label.setter
+    def label(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "label", value)
+
+    @property
+    @pulumi.getter(name="messageId")
+    def message_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        Identifier of the message.
+        """
+        return pulumi.get(self, "message_id")
+
+    @message_id.setter
+    def message_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "message_id", value)
+
+    @property
+    @pulumi.getter
+    def properties(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
+        """
+        dictionary object for custom filters
+        """
+        return pulumi.get(self, "properties")
+
+    @properties.setter
+    def properties(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
+        pulumi.set(self, "properties", value)
+
+    @property
+    @pulumi.getter(name="replyTo")
+    def reply_to(self) -> Optional[pulumi.Input[str]]:
+        """
+        Address of the queue to reply to.
+        """
+        return pulumi.get(self, "reply_to")
+
+    @reply_to.setter
+    def reply_to(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "reply_to", value)
+
+    @property
+    @pulumi.getter(name="replyToSessionId")
+    def reply_to_session_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        Session identifier to reply to.
+        """
+        return pulumi.get(self, "reply_to_session_id")
+
+    @reply_to_session_id.setter
+    def reply_to_session_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "reply_to_session_id", value)
+
+    @property
+    @pulumi.getter(name="requiresPreprocessing")
+    def requires_preprocessing(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Value that indicates whether the rule action requires preprocessing.
+        """
+        return pulumi.get(self, "requires_preprocessing")
+
+    @requires_preprocessing.setter
+    def requires_preprocessing(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "requires_preprocessing", value)
+
+    @property
+    @pulumi.getter(name="sessionId")
+    def session_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        Session identifier.
+        """
+        return pulumi.get(self, "session_id")
+
+    @session_id.setter
+    def session_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "session_id", value)
+
+    @property
+    @pulumi.getter
+    def to(self) -> Optional[pulumi.Input[str]]:
+        """
+        Address to send to.
+        """
+        return pulumi.get(self, "to")
+
+    @to.setter
+    def to(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "to", value)
+
+
+if not MYPY:
+    class EncryptionArgsDict(TypedDict):
+        """
+        Properties to configure Encryption
+        """
+        key_source: NotRequired[pulumi.Input['KeySource']]
+        """
+        Enumerates the possible value of keySource for Encryption
+        """
+        key_vault_properties: NotRequired[pulumi.Input[Sequence[pulumi.Input['KeyVaultPropertiesArgsDict']]]]
+        """
+        Properties of KeyVault
+        """
+        require_infrastructure_encryption: NotRequired[pulumi.Input[bool]]
+        """
+        Enable Infrastructure Encryption (Double Encryption)
+        """
+elif False:
+    EncryptionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class EncryptionArgs:
+    def __init__(__self__, *,
+                 key_source: Optional[pulumi.Input['KeySource']] = None,
+                 key_vault_properties: Optional[pulumi.Input[Sequence[pulumi.Input['KeyVaultPropertiesArgs']]]] = None,
+                 require_infrastructure_encryption: Optional[pulumi.Input[bool]] = None):
+        """
+        Properties to configure Encryption
+        :param pulumi.Input['KeySource'] key_source: Enumerates the possible value of keySource for Encryption
+        :param pulumi.Input[Sequence[pulumi.Input['KeyVaultPropertiesArgs']]] key_vault_properties: Properties of KeyVault
+        :param pulumi.Input[bool] require_infrastructure_encryption: Enable Infrastructure Encryption (Double Encryption)
+        """
+        if key_source is None:
+            key_source = 'Microsoft.KeyVault'
+        if key_source is not None:
+            pulumi.set(__self__, "key_source", key_source)
+        if key_vault_properties is not None:
+            pulumi.set(__self__, "key_vault_properties", key_vault_properties)
+        if require_infrastructure_encryption is not None:
+            pulumi.set(__self__, "require_infrastructure_encryption", require_infrastructure_encryption)
+
+    @property
+    @pulumi.getter(name="keySource")
+    def key_source(self) -> Optional[pulumi.Input['KeySource']]:
+        """
+        Enumerates the possible value of keySource for Encryption
+        """
+        return pulumi.get(self, "key_source")
+
+    @key_source.setter
+    def key_source(self, value: Optional[pulumi.Input['KeySource']]):
+        pulumi.set(self, "key_source", value)
+
+    @property
+    @pulumi.getter(name="keyVaultProperties")
+    def key_vault_properties(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KeyVaultPropertiesArgs']]]]:
+        """
+        Properties of KeyVault
+        """
+        return pulumi.get(self, "key_vault_properties")
+
+    @key_vault_properties.setter
+    def key_vault_properties(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['KeyVaultPropertiesArgs']]]]):
+        pulumi.set(self, "key_vault_properties", value)
+
+    @property
+    @pulumi.getter(name="requireInfrastructureEncryption")
+    def require_infrastructure_encryption(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Enable Infrastructure Encryption (Double Encryption)
+        """
+        return pulumi.get(self, "require_infrastructure_encryption")
+
+    @require_infrastructure_encryption.setter
+    def require_infrastructure_encryption(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "require_infrastructure_encryption", value)
+
+
+if not MYPY:
+    class GeoDataReplicationPropertiesArgsDict(TypedDict):
+        """
+        GeoDR Replication properties
+        """
+        locations: NotRequired[pulumi.Input[Sequence[pulumi.Input['NamespaceReplicaLocationArgsDict']]]]
+        """
+        A list of regions where replicas of the namespace are maintained.
+        """
+        max_replication_lag_duration_in_seconds: NotRequired[pulumi.Input[int]]
+        """
+        The maximum acceptable lag for data replication operations from the primary replica to a quorum of secondary replicas.  When the lag exceeds the configured amount, operations on the primary replica will be failed. The allowed values are 0 and 5 minutes to 1 day.
+        """
+elif False:
+    GeoDataReplicationPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GeoDataReplicationPropertiesArgs:
+    def __init__(__self__, *,
+                 locations: Optional[pulumi.Input[Sequence[pulumi.Input['NamespaceReplicaLocationArgs']]]] = None,
+                 max_replication_lag_duration_in_seconds: Optional[pulumi.Input[int]] = None):
+        """
+        GeoDR Replication properties
+        :param pulumi.Input[Sequence[pulumi.Input['NamespaceReplicaLocationArgs']]] locations: A list of regions where replicas of the namespace are maintained.
+        :param pulumi.Input[int] max_replication_lag_duration_in_seconds: The maximum acceptable lag for data replication operations from the primary replica to a quorum of secondary replicas.  When the lag exceeds the configured amount, operations on the primary replica will be failed. The allowed values are 0 and 5 minutes to 1 day.
+        """
+        if locations is not None:
+            pulumi.set(__self__, "locations", locations)
+        if max_replication_lag_duration_in_seconds is not None:
+            pulumi.set(__self__, "max_replication_lag_duration_in_seconds", max_replication_lag_duration_in_seconds)
+
+    @property
+    @pulumi.getter
+    def locations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NamespaceReplicaLocationArgs']]]]:
+        """
+        A list of regions where replicas of the namespace are maintained.
+        """
+        return pulumi.get(self, "locations")
+
+    @locations.setter
+    def locations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NamespaceReplicaLocationArgs']]]]):
+        pulumi.set(self, "locations", value)
+
+    @property
+    @pulumi.getter(name="maxReplicationLagDurationInSeconds")
+    def max_replication_lag_duration_in_seconds(self) -> Optional[pulumi.Input[int]]:
+        """
+        The maximum acceptable lag for data replication operations from the primary replica to a quorum of secondary replicas.  When the lag exceeds the configured amount, operations on the primary replica will be failed. The allowed values are 0 and 5 minutes to 1 day.
+        """
+        return pulumi.get(self, "max_replication_lag_duration_in_seconds")
+
+    @max_replication_lag_duration_in_seconds.setter
+    def max_replication_lag_duration_in_seconds(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "max_replication_lag_duration_in_seconds", value)
+
+
+if not MYPY:
+    class IdentityArgsDict(TypedDict):
+        """
+        Properties to configure User Assigned Identities for Bring your Own Keys
+        """
+        type: NotRequired[pulumi.Input['ManagedServiceIdentityType']]
+        """
+        Type of managed service identity.
+        """
+        user_assigned_identities: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Properties for User Assigned Identities
+        """
+elif False:
+    IdentityArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class IdentityArgs:
+    def __init__(__self__, *,
+                 type: Optional[pulumi.Input['ManagedServiceIdentityType']] = None,
+                 user_assigned_identities: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        Properties to configure User Assigned Identities for Bring your Own Keys
+        :param pulumi.Input['ManagedServiceIdentityType'] type: Type of managed service identity.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] user_assigned_identities: Properties for User Assigned Identities
+        """
+        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[pulumi.Input['ManagedServiceIdentityType']]:
+        """
+        Type of managed service identity.
+        """
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: Optional[pulumi.Input['ManagedServiceIdentityType']]):
+        pulumi.set(self, "type", value)
+
+    @property
+    @pulumi.getter(name="userAssignedIdentities")
+    def user_assigned_identities(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Properties for User Assigned Identities
+        """
+        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)
+
+
+if not MYPY:
+    class KeyVaultPropertiesArgsDict(TypedDict):
+        """
+        Properties to configure keyVault Properties
+        """
+        identity: NotRequired[pulumi.Input['UserAssignedIdentityPropertiesArgsDict']]
+        key_name: NotRequired[pulumi.Input[str]]
+        """
+        Name of the Key from KeyVault
+        """
+        key_vault_uri: NotRequired[pulumi.Input[str]]
+        """
+        Uri of KeyVault
+        """
+        key_version: NotRequired[pulumi.Input[str]]
+        """
+        Version of KeyVault
+        """
+elif False:
+    KeyVaultPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class KeyVaultPropertiesArgs:
+    def __init__(__self__, *,
+                 identity: Optional[pulumi.Input['UserAssignedIdentityPropertiesArgs']] = None,
+                 key_name: Optional[pulumi.Input[str]] = None,
+                 key_vault_uri: Optional[pulumi.Input[str]] = None,
+                 key_version: Optional[pulumi.Input[str]] = None):
+        """
+        Properties to configure keyVault Properties
+        :param pulumi.Input[str] key_name: Name of the Key from KeyVault
+        :param pulumi.Input[str] key_vault_uri: Uri of KeyVault
+        :param pulumi.Input[str] key_version: Version of KeyVault
+        """
+        if identity is not None:
+            pulumi.set(__self__, "identity", identity)
+        if key_name is not None:
+            pulumi.set(__self__, "key_name", key_name)
+        if key_vault_uri is not None:
+            pulumi.set(__self__, "key_vault_uri", key_vault_uri)
+        if key_version is not None:
+            pulumi.set(__self__, "key_version", key_version)
+
+    @property
+    @pulumi.getter
+    def identity(self) -> Optional[pulumi.Input['UserAssignedIdentityPropertiesArgs']]:
+        return pulumi.get(self, "identity")
+
+    @identity.setter
+    def identity(self, value: Optional[pulumi.Input['UserAssignedIdentityPropertiesArgs']]):
+        pulumi.set(self, "identity", value)
+
+    @property
+    @pulumi.getter(name="keyName")
+    def key_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Name of the Key from KeyVault
+        """
+        return pulumi.get(self, "key_name")
+
+    @key_name.setter
+    def key_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "key_name", value)
+
+    @property
+    @pulumi.getter(name="keyVaultUri")
+    def key_vault_uri(self) -> Optional[pulumi.Input[str]]:
+        """
+        Uri of KeyVault
+        """
+        return pulumi.get(self, "key_vault_uri")
+
+    @key_vault_uri.setter
+    def key_vault_uri(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "key_vault_uri", value)
+
+    @property
+    @pulumi.getter(name="keyVersion")
+    def key_version(self) -> Optional[pulumi.Input[str]]:
+        """
+        Version of KeyVault
+        """
+        return pulumi.get(self, "key_version")
+
+    @key_version.setter
+    def key_version(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "key_version", value)
+
+
+if not MYPY:
+    class NWRuleSetIpRulesArgsDict(TypedDict):
+        """
+        Description of NetWorkRuleSet - IpRules resource.
+        """
+        action: NotRequired[pulumi.Input[Union[str, 'NetworkRuleIPAction']]]
+        """
+        The IP Filter Action
+        """
+        ip_mask: NotRequired[pulumi.Input[str]]
+        """
+        IP Mask
+        """
+elif False:
+    NWRuleSetIpRulesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NWRuleSetIpRulesArgs:
+    def __init__(__self__, *,
+                 action: Optional[pulumi.Input[Union[str, 'NetworkRuleIPAction']]] = None,
+                 ip_mask: Optional[pulumi.Input[str]] = None):
+        """
+        Description of NetWorkRuleSet - IpRules resource.
+        :param pulumi.Input[Union[str, 'NetworkRuleIPAction']] action: The IP Filter Action
+        :param pulumi.Input[str] ip_mask: IP Mask
+        """
+        if action is None:
+            action = 'Allow'
+        if action is not None:
+            pulumi.set(__self__, "action", action)
+        if ip_mask is not None:
+            pulumi.set(__self__, "ip_mask", ip_mask)
+
+    @property
+    @pulumi.getter
+    def action(self) -> Optional[pulumi.Input[Union[str, 'NetworkRuleIPAction']]]:
+        """
+        The IP Filter Action
+        """
+        return pulumi.get(self, "action")
+
+    @action.setter
+    def action(self, value: Optional[pulumi.Input[Union[str, 'NetworkRuleIPAction']]]):
+        pulumi.set(self, "action", value)
+
+    @property
+    @pulumi.getter(name="ipMask")
+    def ip_mask(self) -> Optional[pulumi.Input[str]]:
+        """
+        IP Mask
+        """
+        return pulumi.get(self, "ip_mask")
+
+    @ip_mask.setter
+    def ip_mask(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "ip_mask", value)
+
+
+if not MYPY:
+    class NWRuleSetVirtualNetworkRulesArgsDict(TypedDict):
+        """
+        Description of VirtualNetworkRules - NetworkRules resource.
+        """
+        ignore_missing_vnet_service_endpoint: NotRequired[pulumi.Input[bool]]
+        """
+        Value that indicates whether to ignore missing VNet Service Endpoint
+        """
+        subnet: NotRequired[pulumi.Input['SubnetArgsDict']]
+        """
+        Subnet properties
+        """
+elif False:
+    NWRuleSetVirtualNetworkRulesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NWRuleSetVirtualNetworkRulesArgs:
+    def __init__(__self__, *,
+                 ignore_missing_vnet_service_endpoint: Optional[pulumi.Input[bool]] = None,
+                 subnet: Optional[pulumi.Input['SubnetArgs']] = None):
+        """
+        Description of VirtualNetworkRules - NetworkRules resource.
+        :param pulumi.Input[bool] ignore_missing_vnet_service_endpoint: Value that indicates whether to ignore missing VNet Service Endpoint
+        :param pulumi.Input['SubnetArgs'] subnet: Subnet properties
+        """
+        if ignore_missing_vnet_service_endpoint is not None:
+            pulumi.set(__self__, "ignore_missing_vnet_service_endpoint", ignore_missing_vnet_service_endpoint)
+        if subnet is not None:
+            pulumi.set(__self__, "subnet", subnet)
+
+    @property
+    @pulumi.getter(name="ignoreMissingVnetServiceEndpoint")
+    def ignore_missing_vnet_service_endpoint(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Value that indicates whether to ignore missing VNet Service Endpoint
+        """
+        return pulumi.get(self, "ignore_missing_vnet_service_endpoint")
+
+    @ignore_missing_vnet_service_endpoint.setter
+    def ignore_missing_vnet_service_endpoint(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "ignore_missing_vnet_service_endpoint", value)
+
+    @property
+    @pulumi.getter
+    def subnet(self) -> Optional[pulumi.Input['SubnetArgs']]:
+        """
+        Subnet properties
+        """
+        return pulumi.get(self, "subnet")
+
+    @subnet.setter
+    def subnet(self, value: Optional[pulumi.Input['SubnetArgs']]):
+        pulumi.set(self, "subnet", value)
+
+
+if not MYPY:
+    class NamespaceReplicaLocationArgsDict(TypedDict):
+        """
+        Namespace replication properties
+        """
+        cluster_arm_id: NotRequired[pulumi.Input[str]]
+        """
+        Optional property that denotes the ARM ID of the Cluster. This is required, if a namespace replica should be placed in a Dedicated Event Hub Cluster
+        """
+        location_name: NotRequired[pulumi.Input[str]]
+        """
+        Azure regions where a replica of the namespace is maintained
+        """
+        role_type: NotRequired[pulumi.Input[Union[str, 'GeoDRRoleType']]]
+        """
+        GeoDR Role Types
+        """
+elif False:
+    NamespaceReplicaLocationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NamespaceReplicaLocationArgs:
+    def __init__(__self__, *,
+                 cluster_arm_id: Optional[pulumi.Input[str]] = None,
+                 location_name: Optional[pulumi.Input[str]] = None,
+                 role_type: Optional[pulumi.Input[Union[str, 'GeoDRRoleType']]] = None):
+        """
+        Namespace replication properties
+        :param pulumi.Input[str] cluster_arm_id: Optional property that denotes the ARM ID of the Cluster. This is required, if a namespace replica should be placed in a Dedicated Event Hub Cluster
+        :param pulumi.Input[str] location_name: Azure regions where a replica of the namespace is maintained
+        :param pulumi.Input[Union[str, 'GeoDRRoleType']] role_type: GeoDR Role Types
+        """
+        if cluster_arm_id is not None:
+            pulumi.set(__self__, "cluster_arm_id", cluster_arm_id)
+        if location_name is not None:
+            pulumi.set(__self__, "location_name", location_name)
+        if role_type is not None:
+            pulumi.set(__self__, "role_type", role_type)
+
+    @property
+    @pulumi.getter(name="clusterArmId")
+    def cluster_arm_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        Optional property that denotes the ARM ID of the Cluster. This is required, if a namespace replica should be placed in a Dedicated Event Hub Cluster
+        """
+        return pulumi.get(self, "cluster_arm_id")
+
+    @cluster_arm_id.setter
+    def cluster_arm_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "cluster_arm_id", value)
+
+    @property
+    @pulumi.getter(name="locationName")
+    def location_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure regions where a replica of the namespace is maintained
+        """
+        return pulumi.get(self, "location_name")
+
+    @location_name.setter
+    def location_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "location_name", value)
+
+    @property
+    @pulumi.getter(name="roleType")
+    def role_type(self) -> Optional[pulumi.Input[Union[str, 'GeoDRRoleType']]]:
+        """
+        GeoDR Role Types
+        """
+        return pulumi.get(self, "role_type")
+
+    @role_type.setter
+    def role_type(self, value: Optional[pulumi.Input[Union[str, 'GeoDRRoleType']]]):
+        pulumi.set(self, "role_type", value)
+
+
+if not MYPY:
+    class PrivateEndpointConnectionArgsDict(TypedDict):
+        """
+        Properties of the PrivateEndpointConnection.
+        """
+        private_endpoint: NotRequired[pulumi.Input['PrivateEndpointArgsDict']]
+        """
+        The Private Endpoint resource for this Connection.
+        """
+        private_link_service_connection_state: NotRequired[pulumi.Input['ConnectionStateArgsDict']]
+        """
+        Details about the state of the connection.
+        """
+        provisioning_state: NotRequired[pulumi.Input[Union[str, 'EndPointProvisioningState']]]
+        """
+        Provisioning state of the Private Endpoint Connection.
+        """
+elif False:
+    PrivateEndpointConnectionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PrivateEndpointConnectionArgs:
+    def __init__(__self__, *,
+                 private_endpoint: Optional[pulumi.Input['PrivateEndpointArgs']] = None,
+                 private_link_service_connection_state: Optional[pulumi.Input['ConnectionStateArgs']] = None,
+                 provisioning_state: Optional[pulumi.Input[Union[str, 'EndPointProvisioningState']]] = None):
+        """
+        Properties of the PrivateEndpointConnection.
+        :param pulumi.Input['PrivateEndpointArgs'] private_endpoint: The Private Endpoint resource for this Connection.
+        :param pulumi.Input['ConnectionStateArgs'] private_link_service_connection_state: Details about the state of the connection.
+        :param pulumi.Input[Union[str, 'EndPointProvisioningState']] provisioning_state: Provisioning state of the Private Endpoint Connection.
+        """
+        if private_endpoint is not None:
+            pulumi.set(__self__, "private_endpoint", private_endpoint)
+        if private_link_service_connection_state is not None:
+            pulumi.set(__self__, "private_link_service_connection_state", private_link_service_connection_state)
+        if provisioning_state is not None:
+            pulumi.set(__self__, "provisioning_state", provisioning_state)
+
+    @property
+    @pulumi.getter(name="privateEndpoint")
+    def private_endpoint(self) -> Optional[pulumi.Input['PrivateEndpointArgs']]:
+        """
+        The Private Endpoint resource for this Connection.
+        """
+        return pulumi.get(self, "private_endpoint")
+
+    @private_endpoint.setter
+    def private_endpoint(self, value: Optional[pulumi.Input['PrivateEndpointArgs']]):
+        pulumi.set(self, "private_endpoint", value)
+
+    @property
+    @pulumi.getter(name="privateLinkServiceConnectionState")
+    def private_link_service_connection_state(self) -> Optional[pulumi.Input['ConnectionStateArgs']]:
+        """
+        Details about the state of the connection.
+        """
+        return pulumi.get(self, "private_link_service_connection_state")
+
+    @private_link_service_connection_state.setter
+    def private_link_service_connection_state(self, value: Optional[pulumi.Input['ConnectionStateArgs']]):
+        pulumi.set(self, "private_link_service_connection_state", value)
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> Optional[pulumi.Input[Union[str, 'EndPointProvisioningState']]]:
+        """
+        Provisioning state of the Private Endpoint Connection.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @provisioning_state.setter
+    def provisioning_state(self, value: Optional[pulumi.Input[Union[str, 'EndPointProvisioningState']]]):
+        pulumi.set(self, "provisioning_state", value)
+
+
+if not MYPY:
+    class PrivateEndpointArgsDict(TypedDict):
+        """
+        PrivateEndpoint information.
+        """
+        id: NotRequired[pulumi.Input[str]]
+        """
+        The ARM identifier for Private Endpoint.
+        """
+elif False:
+    PrivateEndpointArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PrivateEndpointArgs:
+    def __init__(__self__, *,
+                 id: Optional[pulumi.Input[str]] = None):
+        """
+        PrivateEndpoint information.
+        :param pulumi.Input[str] id: The ARM identifier for Private Endpoint.
+        """
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The ARM identifier for Private Endpoint.
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "id", value)
+
+
+if not MYPY:
+    class SBClientAffinePropertiesArgsDict(TypedDict):
+        """
+        Properties specific to client affine subscriptions.
+        """
+        client_id: NotRequired[pulumi.Input[str]]
+        """
+        Indicates the Client ID of the application that created the client-affine subscription.
+        """
+        is_durable: NotRequired[pulumi.Input[bool]]
+        """
+        For client-affine subscriptions, this value indicates whether the subscription is durable or not.
+        """
+        is_shared: NotRequired[pulumi.Input[bool]]
+        """
+        For client-affine subscriptions, this value indicates whether the subscription is shared or not.
+        """
+elif False:
+    SBClientAffinePropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SBClientAffinePropertiesArgs:
+    def __init__(__self__, *,
+                 client_id: Optional[pulumi.Input[str]] = None,
+                 is_durable: Optional[pulumi.Input[bool]] = None,
+                 is_shared: Optional[pulumi.Input[bool]] = None):
+        """
+        Properties specific to client affine subscriptions.
+        :param pulumi.Input[str] client_id: Indicates the Client ID of the application that created the client-affine subscription.
+        :param pulumi.Input[bool] is_durable: For client-affine subscriptions, this value indicates whether the subscription is durable or not.
+        :param pulumi.Input[bool] is_shared: For client-affine subscriptions, this value indicates whether the subscription is shared or not.
+        """
+        if client_id is not None:
+            pulumi.set(__self__, "client_id", client_id)
+        if is_durable is not None:
+            pulumi.set(__self__, "is_durable", is_durable)
+        if is_shared is not None:
+            pulumi.set(__self__, "is_shared", is_shared)
+
+    @property
+    @pulumi.getter(name="clientId")
+    def client_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        Indicates the Client ID of the application that created the client-affine subscription.
+        """
+        return pulumi.get(self, "client_id")
+
+    @client_id.setter
+    def client_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "client_id", value)
+
+    @property
+    @pulumi.getter(name="isDurable")
+    def is_durable(self) -> Optional[pulumi.Input[bool]]:
+        """
+        For client-affine subscriptions, this value indicates whether the subscription is durable or not.
+        """
+        return pulumi.get(self, "is_durable")
+
+    @is_durable.setter
+    def is_durable(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_durable", value)
+
+    @property
+    @pulumi.getter(name="isShared")
+    def is_shared(self) -> Optional[pulumi.Input[bool]]:
+        """
+        For client-affine subscriptions, this value indicates whether the subscription is shared or not.
+        """
+        return pulumi.get(self, "is_shared")
+
+    @is_shared.setter
+    def is_shared(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_shared", value)
+
+
+if not MYPY:
+    class SBSkuArgsDict(TypedDict):
+        """
+        SKU of the namespace.
+        """
+        name: pulumi.Input['SkuName']
+        """
+        Name of this SKU.
+        """
+        capacity: NotRequired[pulumi.Input[int]]
+        """
+        Messaging units for your service bus premium namespace. Valid capacities are {1, 2, 4, 8, 16} multiples of your properties.premiumMessagingPartitions setting. For example, If properties.premiumMessagingPartitions is 1 then possible capacity values are 1, 2, 4, 8, and 16. If properties.premiumMessagingPartitions is 4 then possible capacity values are 4, 8, 16, 32 and 64
+        """
+        tier: NotRequired[pulumi.Input['SkuTier']]
+        """
+        The billing tier of this particular SKU.
+        """
+elif False:
+    SBSkuArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SBSkuArgs:
+    def __init__(__self__, *,
+                 name: pulumi.Input['SkuName'],
+                 capacity: Optional[pulumi.Input[int]] = None,
+                 tier: Optional[pulumi.Input['SkuTier']] = None):
+        """
+        SKU of the namespace.
+        :param pulumi.Input['SkuName'] name: Name of this SKU.
+        :param pulumi.Input[int] capacity: Messaging units for your service bus premium namespace. Valid capacities are {1, 2, 4, 8, 16} multiples of your properties.premiumMessagingPartitions setting. For example, If properties.premiumMessagingPartitions is 1 then possible capacity values are 1, 2, 4, 8, and 16. If properties.premiumMessagingPartitions is 4 then possible capacity values are 4, 8, 16, 32 and 64
+        :param pulumi.Input['SkuTier'] tier: The billing tier of this particular SKU.
+        """
+        pulumi.set(__self__, "name", name)
+        if capacity is not None:
+            pulumi.set(__self__, "capacity", capacity)
+        if tier is not None:
+            pulumi.set(__self__, "tier", tier)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input['SkuName']:
+        """
+        Name of this SKU.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input['SkuName']):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def capacity(self) -> Optional[pulumi.Input[int]]:
+        """
+        Messaging units for your service bus premium namespace. Valid capacities are {1, 2, 4, 8, 16} multiples of your properties.premiumMessagingPartitions setting. For example, If properties.premiumMessagingPartitions is 1 then possible capacity values are 1, 2, 4, 8, and 16. If properties.premiumMessagingPartitions is 4 then possible capacity values are 4, 8, 16, 32 and 64
+        """
+        return pulumi.get(self, "capacity")
+
+    @capacity.setter
+    def capacity(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "capacity", value)
+
+    @property
+    @pulumi.getter
+    def tier(self) -> Optional[pulumi.Input['SkuTier']]:
+        """
+        The billing tier of this particular SKU.
+        """
+        return pulumi.get(self, "tier")
+
+    @tier.setter
+    def tier(self, value: Optional[pulumi.Input['SkuTier']]):
+        pulumi.set(self, "tier", value)
+
+
+if not MYPY:
+    class SqlFilterArgsDict(TypedDict):
+        """
+        Represents a filter which is a composition of an expression and an action that is executed in the pub/sub pipeline.
+        """
+        compatibility_level: NotRequired[pulumi.Input[int]]
+        """
+        This property is reserved for future use. An integer value showing the compatibility level, currently hard-coded to 20.
+        """
+        requires_preprocessing: NotRequired[pulumi.Input[bool]]
+        """
+        Value that indicates whether the rule action requires preprocessing.
+        """
+        sql_expression: NotRequired[pulumi.Input[str]]
+        """
+        The SQL expression. e.g. MyProperty='ABC'
+        """
+elif False:
+    SqlFilterArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SqlFilterArgs:
+    def __init__(__self__, *,
+                 compatibility_level: Optional[pulumi.Input[int]] = None,
+                 requires_preprocessing: Optional[pulumi.Input[bool]] = None,
+                 sql_expression: Optional[pulumi.Input[str]] = None):
+        """
+        Represents a filter which is a composition of an expression and an action that is executed in the pub/sub pipeline.
+        :param pulumi.Input[int] compatibility_level: This property is reserved for future use. An integer value showing the compatibility level, currently hard-coded to 20.
+        :param pulumi.Input[bool] requires_preprocessing: Value that indicates whether the rule action requires preprocessing.
+        :param pulumi.Input[str] sql_expression: The SQL expression. e.g. MyProperty='ABC'
+        """
+        if compatibility_level is not None:
+            pulumi.set(__self__, "compatibility_level", compatibility_level)
+        if requires_preprocessing is None:
+            requires_preprocessing = True
+        if requires_preprocessing is not None:
+            pulumi.set(__self__, "requires_preprocessing", requires_preprocessing)
+        if sql_expression is not None:
+            pulumi.set(__self__, "sql_expression", sql_expression)
+
+    @property
+    @pulumi.getter(name="compatibilityLevel")
+    def compatibility_level(self) -> Optional[pulumi.Input[int]]:
+        """
+        This property is reserved for future use. An integer value showing the compatibility level, currently hard-coded to 20.
+        """
+        return pulumi.get(self, "compatibility_level")
+
+    @compatibility_level.setter
+    def compatibility_level(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "compatibility_level", value)
+
+    @property
+    @pulumi.getter(name="requiresPreprocessing")
+    def requires_preprocessing(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Value that indicates whether the rule action requires preprocessing.
+        """
+        return pulumi.get(self, "requires_preprocessing")
+
+    @requires_preprocessing.setter
+    def requires_preprocessing(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "requires_preprocessing", value)
+
+    @property
+    @pulumi.getter(name="sqlExpression")
+    def sql_expression(self) -> Optional[pulumi.Input[str]]:
+        """
+        The SQL expression. e.g. MyProperty='ABC'
+        """
+        return pulumi.get(self, "sql_expression")
+
+    @sql_expression.setter
+    def sql_expression(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "sql_expression", value)
+
+
+if not MYPY:
+    class SubnetArgsDict(TypedDict):
+        """
+        Properties supplied for Subnet
+        """
+        id: pulumi.Input[str]
+        """
+        Resource ID of Virtual Network Subnet
+        """
+elif False:
+    SubnetArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SubnetArgs:
+    def __init__(__self__, *,
+                 id: pulumi.Input[str]):
+        """
+        Properties supplied for Subnet
+        :param pulumi.Input[str] id: Resource ID of Virtual Network Subnet
+        """
+        pulumi.set(__self__, "id", id)
+
+    @property
+    @pulumi.getter
+    def id(self) -> pulumi.Input[str]:
+        """
+        Resource ID of Virtual Network Subnet
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "id", value)
+
+
+if not MYPY:
+    class UserAssignedIdentityPropertiesArgsDict(TypedDict):
+        user_assigned_identity: NotRequired[pulumi.Input[str]]
+        """
+        ARM ID of user Identity selected for encryption
+        """
+elif False:
+    UserAssignedIdentityPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class UserAssignedIdentityPropertiesArgs:
+    def __init__(__self__, *,
+                 user_assigned_identity: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] user_assigned_identity: ARM ID of user Identity selected for encryption
+        """
+        if user_assigned_identity is not None:
+            pulumi.set(__self__, "user_assigned_identity", user_assigned_identity)
+
+    @property
+    @pulumi.getter(name="userAssignedIdentity")
+    def user_assigned_identity(self) -> Optional[pulumi.Input[str]]:
+        """
+        ARM ID of user Identity selected for encryption
+        """
+        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)
+
+