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

pulumi_azure_native/servicebus/v20230101preview/_inputs.py

@@ -1,1285 +0,0 @@
-# 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)
-
-