pulumi-azure-native 2.58.0a1724403460__py3-none-any.whl → 2.59.0a1724845184__py3-none-any.whl

pulumi_azure_native/security/_inputs.py

@@ -226,14 +226,8 @@ __all__ = [
     'OnPremiseSqlResourceDetailsArgsDict',
     'OnUploadPropertiesArgs',
     'OnUploadPropertiesArgsDict',
-    'PathRecommendationArgs',
-    'PathRecommendationArgsDict',
-    'ProtectionModeArgs',
-    'ProtectionModeArgsDict',
     'ProxyServerPropertiesArgs',
     'ProxyServerPropertiesArgsDict',
-    'PublisherInfoArgs',
-    'PublisherInfoArgsDict',
     'RecommendationConfigurationPropertiesArgs',
     'RecommendationConfigurationPropertiesArgsDict',
     'RemediationEtaArgs',
@@ -266,10 +260,6 @@ __all__ = [
     'TimeWindowCustomAlertRuleArgsDict',
     'UserDefinedResourcesPropertiesArgs',
     'UserDefinedResourcesPropertiesArgsDict',
-    'UserRecommendationArgs',
-    'UserRecommendationArgsDict',
-    'VmRecommendationArgs',
-    'VmRecommendationArgsDict',
 ]
 
 MYPY = False
@@ -7393,284 +7383,6 @@ class OnUploadPropertiesArgs:
         pulumi.set(self, "is_enabled", value)
 
 
-if not MYPY:
-    class PathRecommendationArgsDict(TypedDict):
-        """
-        Represents a path that is recommended to be allowed and its properties
-        """
-        action: NotRequired[pulumi.Input[str]]
-        """
-        The recommendation action of the machine or rule
-        """
-        common: NotRequired[pulumi.Input[bool]]
-        """
-        Whether the application is commonly run on the machine
-        """
-        configuration_status: NotRequired[pulumi.Input[str]]
-        """
-        The configuration status of the machines group or machine or rule
-        """
-        file_type: NotRequired[pulumi.Input[str]]
-        """
-        The type of the file (for Linux files - Executable is used)
-        """
-        path: NotRequired[pulumi.Input[str]]
-        """
-        The full path of the file, or an identifier of the application
-        """
-        publisher_info: NotRequired[pulumi.Input['PublisherInfoArgsDict']]
-        """
-        Represents the publisher information of a process/rule
-        """
-        type: NotRequired[pulumi.Input[str]]
-        """
-        The type of the rule to be allowed
-        """
-        user_sids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        usernames: NotRequired[pulumi.Input[Sequence[pulumi.Input['UserRecommendationArgsDict']]]]
-elif False:
-    PathRecommendationArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class PathRecommendationArgs:
-    def __init__(__self__, *,
-                 action: Optional[pulumi.Input[str]] = None,
-                 common: Optional[pulumi.Input[bool]] = None,
-                 configuration_status: Optional[pulumi.Input[str]] = None,
-                 file_type: Optional[pulumi.Input[str]] = None,
-                 path: Optional[pulumi.Input[str]] = None,
-                 publisher_info: Optional[pulumi.Input['PublisherInfoArgs']] = None,
-                 type: Optional[pulumi.Input[str]] = None,
-                 user_sids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
-                 usernames: Optional[pulumi.Input[Sequence[pulumi.Input['UserRecommendationArgs']]]] = None):
-        """
-        Represents a path that is recommended to be allowed and its properties
-        :param pulumi.Input[str] action: The recommendation action of the machine or rule
-        :param pulumi.Input[bool] common: Whether the application is commonly run on the machine
-        :param pulumi.Input[str] configuration_status: The configuration status of the machines group or machine or rule
-        :param pulumi.Input[str] file_type: The type of the file (for Linux files - Executable is used)
-        :param pulumi.Input[str] path: The full path of the file, or an identifier of the application
-        :param pulumi.Input['PublisherInfoArgs'] publisher_info: Represents the publisher information of a process/rule
-        :param pulumi.Input[str] type: The type of the rule to be allowed
-        """
-        if action is not None:
-            pulumi.set(__self__, "action", action)
-        if common is not None:
-            pulumi.set(__self__, "common", common)
-        if configuration_status is not None:
-            pulumi.set(__self__, "configuration_status", configuration_status)
-        if file_type is not None:
-            pulumi.set(__self__, "file_type", file_type)
-        if path is not None:
-            pulumi.set(__self__, "path", path)
-        if publisher_info is not None:
-            pulumi.set(__self__, "publisher_info", publisher_info)
-        if type is not None:
-            pulumi.set(__self__, "type", type)
-        if user_sids is not None:
-            pulumi.set(__self__, "user_sids", user_sids)
-        if usernames is not None:
-            pulumi.set(__self__, "usernames", usernames)
-
-    @property
-    @pulumi.getter
-    def action(self) -> Optional[pulumi.Input[str]]:
-        """
-        The recommendation action of the machine or rule
-        """
-        return pulumi.get(self, "action")
-
-    @action.setter
-    def action(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "action", value)
-
-    @property
-    @pulumi.getter
-    def common(self) -> Optional[pulumi.Input[bool]]:
-        """
-        Whether the application is commonly run on the machine
-        """
-        return pulumi.get(self, "common")
-
-    @common.setter
-    def common(self, value: Optional[pulumi.Input[bool]]):
-        pulumi.set(self, "common", value)
-
-    @property
-    @pulumi.getter(name="configurationStatus")
-    def configuration_status(self) -> Optional[pulumi.Input[str]]:
-        """
-        The configuration status of the machines group or machine or rule
-        """
-        return pulumi.get(self, "configuration_status")
-
-    @configuration_status.setter
-    def configuration_status(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "configuration_status", value)
-
-    @property
-    @pulumi.getter(name="fileType")
-    def file_type(self) -> Optional[pulumi.Input[str]]:
-        """
-        The type of the file (for Linux files - Executable is used)
-        """
-        return pulumi.get(self, "file_type")
-
-    @file_type.setter
-    def file_type(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "file_type", value)
-
-    @property
-    @pulumi.getter
-    def path(self) -> Optional[pulumi.Input[str]]:
-        """
-        The full path of the file, or an identifier of the application
-        """
-        return pulumi.get(self, "path")
-
-    @path.setter
-    def path(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "path", value)
-
-    @property
-    @pulumi.getter(name="publisherInfo")
-    def publisher_info(self) -> Optional[pulumi.Input['PublisherInfoArgs']]:
-        """
-        Represents the publisher information of a process/rule
-        """
-        return pulumi.get(self, "publisher_info")
-
-    @publisher_info.setter
-    def publisher_info(self, value: Optional[pulumi.Input['PublisherInfoArgs']]):
-        pulumi.set(self, "publisher_info", value)
-
-    @property
-    @pulumi.getter
-    def type(self) -> Optional[pulumi.Input[str]]:
-        """
-        The type of the rule to be allowed
-        """
-        return pulumi.get(self, "type")
-
-    @type.setter
-    def type(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "type", value)
-
-    @property
-    @pulumi.getter(name="userSids")
-    def user_sids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
-        return pulumi.get(self, "user_sids")
-
-    @user_sids.setter
-    def user_sids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
-        pulumi.set(self, "user_sids", value)
-
-    @property
-    @pulumi.getter
-    def usernames(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['UserRecommendationArgs']]]]:
-        return pulumi.get(self, "usernames")
-
-    @usernames.setter
-    def usernames(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['UserRecommendationArgs']]]]):
-        pulumi.set(self, "usernames", value)
-
-
-if not MYPY:
-    class ProtectionModeArgsDict(TypedDict):
-        """
-        The protection mode of the collection/file types. Exe/Msi/Script are used for Windows, Executable is used for Linux.
-        """
-        exe: NotRequired[pulumi.Input[str]]
-        """
-        The application control policy enforcement/protection mode of the machine group
-        """
-        executable: NotRequired[pulumi.Input[str]]
-        """
-        The application control policy enforcement/protection mode of the machine group
-        """
-        msi: NotRequired[pulumi.Input[str]]
-        """
-        The application control policy enforcement/protection mode of the machine group
-        """
-        script: NotRequired[pulumi.Input[str]]
-        """
-        The application control policy enforcement/protection mode of the machine group
-        """
-elif False:
-    ProtectionModeArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class ProtectionModeArgs:
-    def __init__(__self__, *,
-                 exe: Optional[pulumi.Input[str]] = None,
-                 executable: Optional[pulumi.Input[str]] = None,
-                 msi: Optional[pulumi.Input[str]] = None,
-                 script: Optional[pulumi.Input[str]] = None):
-        """
-        The protection mode of the collection/file types. Exe/Msi/Script are used for Windows, Executable is used for Linux.
-        :param pulumi.Input[str] exe: The application control policy enforcement/protection mode of the machine group
-        :param pulumi.Input[str] executable: The application control policy enforcement/protection mode of the machine group
-        :param pulumi.Input[str] msi: The application control policy enforcement/protection mode of the machine group
-        :param pulumi.Input[str] script: The application control policy enforcement/protection mode of the machine group
-        """
-        if exe is not None:
-            pulumi.set(__self__, "exe", exe)
-        if executable is not None:
-            pulumi.set(__self__, "executable", executable)
-        if msi is not None:
-            pulumi.set(__self__, "msi", msi)
-        if script is not None:
-            pulumi.set(__self__, "script", script)
-
-    @property
-    @pulumi.getter
-    def exe(self) -> Optional[pulumi.Input[str]]:
-        """
-        The application control policy enforcement/protection mode of the machine group
-        """
-        return pulumi.get(self, "exe")
-
-    @exe.setter
-    def exe(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "exe", value)
-
-    @property
-    @pulumi.getter
-    def executable(self) -> Optional[pulumi.Input[str]]:
-        """
-        The application control policy enforcement/protection mode of the machine group
-        """
-        return pulumi.get(self, "executable")
-
-    @executable.setter
-    def executable(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "executable", value)
-
-    @property
-    @pulumi.getter
-    def msi(self) -> Optional[pulumi.Input[str]]:
-        """
-        The application control policy enforcement/protection mode of the machine group
-        """
-        return pulumi.get(self, "msi")
-
-    @msi.setter
-    def msi(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "msi", value)
-
-    @property
-    @pulumi.getter
-    def script(self) -> Optional[pulumi.Input[str]]:
-        """
-        The application control policy enforcement/protection mode of the machine group
-        """
-        return pulumi.get(self, "script")
-
-    @script.setter
-    def script(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "script", value)
-
-
 if not MYPY:
     class ProxyServerPropertiesArgsDict(TypedDict):
         """
@@ -7727,102 +7439,6 @@ class ProxyServerPropertiesArgs:
         pulumi.set(self, "port", value)
 
 
-if not MYPY:
-    class PublisherInfoArgsDict(TypedDict):
-        """
-        Represents the publisher information of a process/rule
-        """
-        binary_name: NotRequired[pulumi.Input[str]]
-        """
-        The "OriginalName" field taken from the file's version resource
-        """
-        product_name: NotRequired[pulumi.Input[str]]
-        """
-        The product name taken from the file's version resource
-        """
-        publisher_name: NotRequired[pulumi.Input[str]]
-        """
-        The Subject field of the x.509 certificate used to sign the code, using the following fields -  O = Organization, L = Locality, S = State or Province, and C = Country
-        """
-        version: NotRequired[pulumi.Input[str]]
-        """
-        The binary file version taken from the file's version resource
-        """
-elif False:
-    PublisherInfoArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class PublisherInfoArgs:
-    def __init__(__self__, *,
-                 binary_name: Optional[pulumi.Input[str]] = None,
-                 product_name: Optional[pulumi.Input[str]] = None,
-                 publisher_name: Optional[pulumi.Input[str]] = None,
-                 version: Optional[pulumi.Input[str]] = None):
-        """
-        Represents the publisher information of a process/rule
-        :param pulumi.Input[str] binary_name: The "OriginalName" field taken from the file's version resource
-        :param pulumi.Input[str] product_name: The product name taken from the file's version resource
-        :param pulumi.Input[str] publisher_name: The Subject field of the x.509 certificate used to sign the code, using the following fields -  O = Organization, L = Locality, S = State or Province, and C = Country
-        :param pulumi.Input[str] version: The binary file version taken from the file's version resource
-        """
-        if binary_name is not None:
-            pulumi.set(__self__, "binary_name", binary_name)
-        if product_name is not None:
-            pulumi.set(__self__, "product_name", product_name)
-        if publisher_name is not None:
-            pulumi.set(__self__, "publisher_name", publisher_name)
-        if version is not None:
-            pulumi.set(__self__, "version", version)
-
-    @property
-    @pulumi.getter(name="binaryName")
-    def binary_name(self) -> Optional[pulumi.Input[str]]:
-        """
-        The "OriginalName" field taken from the file's version resource
-        """
-        return pulumi.get(self, "binary_name")
-
-    @binary_name.setter
-    def binary_name(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "binary_name", value)
-
-    @property
-    @pulumi.getter(name="productName")
-    def product_name(self) -> Optional[pulumi.Input[str]]:
-        """
-        The product name taken from the file's version resource
-        """
-        return pulumi.get(self, "product_name")
-
-    @product_name.setter
-    def product_name(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "product_name", value)
-
-    @property
-    @pulumi.getter(name="publisherName")
-    def publisher_name(self) -> Optional[pulumi.Input[str]]:
-        """
-        The Subject field of the x.509 certificate used to sign the code, using the following fields -  O = Organization, L = Locality, S = State or Province, and C = Country
-        """
-        return pulumi.get(self, "publisher_name")
-
-    @publisher_name.setter
-    def publisher_name(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "publisher_name", value)
-
-    @property
-    @pulumi.getter
-    def version(self) -> Optional[pulumi.Input[str]]:
-        """
-        The binary file version taken from the file's version resource
-        """
-        return pulumi.get(self, "version")
-
-    @version.setter
-    def version(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "version", value)
-
-
 if not MYPY:
     class RecommendationConfigurationPropertiesArgsDict(TypedDict):
         """
@@ -8885,155 +8501,3 @@ class UserDefinedResourcesPropertiesArgs:
         pulumi.set(self, "query_subscriptions", value)
 
 
-if not MYPY:
-    class UserRecommendationArgsDict(TypedDict):
-        """
-        Represents a user that is recommended to be allowed for a certain rule
-        """
-        recommendation_action: NotRequired[pulumi.Input[str]]
-        """
-        The recommendation action of the machine or rule
-        """
-        username: NotRequired[pulumi.Input[str]]
-        """
-        Represents a user that is recommended to be allowed for a certain rule
-        """
-elif False:
-    UserRecommendationArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class UserRecommendationArgs:
-    def __init__(__self__, *,
-                 recommendation_action: Optional[pulumi.Input[str]] = None,
-                 username: Optional[pulumi.Input[str]] = None):
-        """
-        Represents a user that is recommended to be allowed for a certain rule
-        :param pulumi.Input[str] recommendation_action: The recommendation action of the machine or rule
-        :param pulumi.Input[str] username: Represents a user that is recommended to be allowed for a certain rule
-        """
-        if recommendation_action is not None:
-            pulumi.set(__self__, "recommendation_action", recommendation_action)
-        if username is not None:
-            pulumi.set(__self__, "username", username)
-
-    @property
-    @pulumi.getter(name="recommendationAction")
-    def recommendation_action(self) -> Optional[pulumi.Input[str]]:
-        """
-        The recommendation action of the machine or rule
-        """
-        return pulumi.get(self, "recommendation_action")
-
-    @recommendation_action.setter
-    def recommendation_action(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "recommendation_action", value)
-
-    @property
-    @pulumi.getter
-    def username(self) -> Optional[pulumi.Input[str]]:
-        """
-        Represents a user that is recommended to be allowed for a certain rule
-        """
-        return pulumi.get(self, "username")
-
-    @username.setter
-    def username(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "username", value)
-
-
-if not MYPY:
-    class VmRecommendationArgsDict(TypedDict):
-        """
-        Represents a machine that is part of a machine group
-        """
-        configuration_status: NotRequired[pulumi.Input[str]]
-        """
-        The configuration status of the machines group or machine or rule
-        """
-        enforcement_support: NotRequired[pulumi.Input[str]]
-        """
-        The machine supportability of Enforce feature
-        """
-        recommendation_action: NotRequired[pulumi.Input[str]]
-        """
-        The recommendation action of the machine or rule
-        """
-        resource_id: NotRequired[pulumi.Input[str]]
-        """
-        The full resource id of the machine
-        """
-elif False:
-    VmRecommendationArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class VmRecommendationArgs:
-    def __init__(__self__, *,
-                 configuration_status: Optional[pulumi.Input[str]] = None,
-                 enforcement_support: Optional[pulumi.Input[str]] = None,
-                 recommendation_action: Optional[pulumi.Input[str]] = None,
-                 resource_id: Optional[pulumi.Input[str]] = None):
-        """
-        Represents a machine that is part of a machine group
-        :param pulumi.Input[str] configuration_status: The configuration status of the machines group or machine or rule
-        :param pulumi.Input[str] enforcement_support: The machine supportability of Enforce feature
-        :param pulumi.Input[str] recommendation_action: The recommendation action of the machine or rule
-        :param pulumi.Input[str] resource_id: The full resource id of the machine
-        """
-        if configuration_status is not None:
-            pulumi.set(__self__, "configuration_status", configuration_status)
-        if enforcement_support is not None:
-            pulumi.set(__self__, "enforcement_support", enforcement_support)
-        if recommendation_action is not None:
-            pulumi.set(__self__, "recommendation_action", recommendation_action)
-        if resource_id is not None:
-            pulumi.set(__self__, "resource_id", resource_id)
-
-    @property
-    @pulumi.getter(name="configurationStatus")
-    def configuration_status(self) -> Optional[pulumi.Input[str]]:
-        """
-        The configuration status of the machines group or machine or rule
-        """
-        return pulumi.get(self, "configuration_status")
-
-    @configuration_status.setter
-    def configuration_status(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "configuration_status", value)
-
-    @property
-    @pulumi.getter(name="enforcementSupport")
-    def enforcement_support(self) -> Optional[pulumi.Input[str]]:
-        """
-        The machine supportability of Enforce feature
-        """
-        return pulumi.get(self, "enforcement_support")
-
-    @enforcement_support.setter
-    def enforcement_support(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "enforcement_support", value)
-
-    @property
-    @pulumi.getter(name="recommendationAction")
-    def recommendation_action(self) -> Optional[pulumi.Input[str]]:
-        """
-        The recommendation action of the machine or rule
-        """
-        return pulumi.get(self, "recommendation_action")
-
-    @recommendation_action.setter
-    def recommendation_action(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "recommendation_action", value)
-
-    @property
-    @pulumi.getter(name="resourceId")
-    def resource_id(self) -> Optional[pulumi.Input[str]]:
-        """
-        The full resource id of the machine
-        """
-        return pulumi.get(self, "resource_id")
-
-    @resource_id.setter
-    def resource_id(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "resource_id", value)
-
-