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

pulumi_azure_native/security/outputs.py

@@ -18,7 +18,6 @@ from ._enums import *
 
 __all__ = [
     'ActionableRemediationResponse',
-    'AdaptiveApplicationControlIssueSummaryResponse',
     'AdditionalWorkspacesPropertiesResponse',
     'AllowlistCustomAlertRuleResponse',
     'AssessmentLinksResponse',
@@ -135,10 +134,7 @@ __all__ = [
     'OnPremiseSqlResourceDetailsResponse',
     'OnUploadPropertiesResponse',
     'OperationStatusResponse',
-    'PathRecommendationResponse',
-    'ProtectionModeResponse',
     'ProxyServerPropertiesResponse',
-    'PublisherInfoResponse',
     'RecommendationConfigurationPropertiesResponse',
     'RemediationEtaResponse',
     'RuleResultsPropertiesResponse',
@@ -158,8 +154,6 @@ __all__ = [
     'ThresholdCustomAlertRuleResponse',
     'TimeWindowCustomAlertRuleResponse',
     'UserDefinedResourcesPropertiesResponse',
-    'UserRecommendationResponse',
-    'VmRecommendationResponse',
 ]
 
 @pulumi.output_type
@@ -233,58 +227,6 @@ class ActionableRemediationResponse(dict):
         return pulumi.get(self, "state")
 
 
-@pulumi.output_type
-class AdaptiveApplicationControlIssueSummaryResponse(dict):
-    """
-    Represents a summary of the alerts of the machine group
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "numberOfVms":
-            suggest = "number_of_vms"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in AdaptiveApplicationControlIssueSummaryResponse. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        AdaptiveApplicationControlIssueSummaryResponse.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        AdaptiveApplicationControlIssueSummaryResponse.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 issue: Optional[str] = None,
-                 number_of_vms: Optional[float] = None):
-        """
-        Represents a summary of the alerts of the machine group
-        :param str issue: An alert that machines within a group can have
-        :param float number_of_vms: The number of machines in the group that have this alert
-        """
-        if issue is not None:
-            pulumi.set(__self__, "issue", issue)
-        if number_of_vms is not None:
-            pulumi.set(__self__, "number_of_vms", number_of_vms)
-
-    @property
-    @pulumi.getter
-    def issue(self) -> Optional[str]:
-        """
-        An alert that machines within a group can have
-        """
-        return pulumi.get(self, "issue")
-
-    @property
-    @pulumi.getter(name="numberOfVms")
-    def number_of_vms(self) -> Optional[float]:
-        """
-        The number of machines in the group that have this alert
-        """
-        return pulumi.get(self, "number_of_vms")
-
-
 @pulumi.output_type
 class AdditionalWorkspacesPropertiesResponse(dict):
     """
@@ -7726,199 +7668,6 @@ class OperationStatusResponse(dict):
         return pulumi.get(self, "message")
 
 
-@pulumi.output_type
-class PathRecommendationResponse(dict):
-    """
-    Represents a path that is recommended to be allowed and its properties
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "configurationStatus":
-            suggest = "configuration_status"
-        elif key == "fileType":
-            suggest = "file_type"
-        elif key == "publisherInfo":
-            suggest = "publisher_info"
-        elif key == "userSids":
-            suggest = "user_sids"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in PathRecommendationResponse. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        PathRecommendationResponse.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        PathRecommendationResponse.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 action: Optional[str] = None,
-                 common: Optional[bool] = None,
-                 configuration_status: Optional[str] = None,
-                 file_type: Optional[str] = None,
-                 path: Optional[str] = None,
-                 publisher_info: Optional['outputs.PublisherInfoResponse'] = None,
-                 type: Optional[str] = None,
-                 user_sids: Optional[Sequence[str]] = None,
-                 usernames: Optional[Sequence['outputs.UserRecommendationResponse']] = None):
-        """
-        Represents a path that is recommended to be allowed and its properties
-        :param str action: The recommendation action of the machine or rule
-        :param bool common: Whether the application is commonly run on the machine
-        :param str configuration_status: The configuration status of the machines group or machine or rule
-        :param str file_type: The type of the file (for Linux files - Executable is used)
-        :param str path: The full path of the file, or an identifier of the application
-        :param 'PublisherInfoResponse' publisher_info: Represents the publisher information of a process/rule
-        :param 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[str]:
-        """
-        The recommendation action of the machine or rule
-        """
-        return pulumi.get(self, "action")
-
-    @property
-    @pulumi.getter
-    def common(self) -> Optional[bool]:
-        """
-        Whether the application is commonly run on the machine
-        """
-        return pulumi.get(self, "common")
-
-    @property
-    @pulumi.getter(name="configurationStatus")
-    def configuration_status(self) -> Optional[str]:
-        """
-        The configuration status of the machines group or machine or rule
-        """
-        return pulumi.get(self, "configuration_status")
-
-    @property
-    @pulumi.getter(name="fileType")
-    def file_type(self) -> Optional[str]:
-        """
-        The type of the file (for Linux files - Executable is used)
-        """
-        return pulumi.get(self, "file_type")
-
-    @property
-    @pulumi.getter
-    def path(self) -> Optional[str]:
-        """
-        The full path of the file, or an identifier of the application
-        """
-        return pulumi.get(self, "path")
-
-    @property
-    @pulumi.getter(name="publisherInfo")
-    def publisher_info(self) -> Optional['outputs.PublisherInfoResponse']:
-        """
-        Represents the publisher information of a process/rule
-        """
-        return pulumi.get(self, "publisher_info")
-
-    @property
-    @pulumi.getter
-    def type(self) -> Optional[str]:
-        """
-        The type of the rule to be allowed
-        """
-        return pulumi.get(self, "type")
-
-    @property
-    @pulumi.getter(name="userSids")
-    def user_sids(self) -> Optional[Sequence[str]]:
-        return pulumi.get(self, "user_sids")
-
-    @property
-    @pulumi.getter
-    def usernames(self) -> Optional[Sequence['outputs.UserRecommendationResponse']]:
-        return pulumi.get(self, "usernames")
-
-
-@pulumi.output_type
-class ProtectionModeResponse(dict):
-    """
-    The protection mode of the collection/file types. Exe/Msi/Script are used for Windows, Executable is used for Linux.
-    """
-    def __init__(__self__, *,
-                 exe: Optional[str] = None,
-                 executable: Optional[str] = None,
-                 msi: Optional[str] = None,
-                 script: Optional[str] = None):
-        """
-        The protection mode of the collection/file types. Exe/Msi/Script are used for Windows, Executable is used for Linux.
-        :param str exe: The application control policy enforcement/protection mode of the machine group
-        :param str executable: The application control policy enforcement/protection mode of the machine group
-        :param str msi: The application control policy enforcement/protection mode of the machine group
-        :param 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[str]:
-        """
-        The application control policy enforcement/protection mode of the machine group
-        """
-        return pulumi.get(self, "exe")
-
-    @property
-    @pulumi.getter
-    def executable(self) -> Optional[str]:
-        """
-        The application control policy enforcement/protection mode of the machine group
-        """
-        return pulumi.get(self, "executable")
-
-    @property
-    @pulumi.getter
-    def msi(self) -> Optional[str]:
-        """
-        The application control policy enforcement/protection mode of the machine group
-        """
-        return pulumi.get(self, "msi")
-
-    @property
-    @pulumi.getter
-    def script(self) -> Optional[str]:
-        """
-        The application control policy enforcement/protection mode of the machine group
-        """
-        return pulumi.get(self, "script")
-
-
 @pulumi.output_type
 class ProxyServerPropertiesResponse(dict):
     """
@@ -7954,86 +7703,6 @@ class ProxyServerPropertiesResponse(dict):
         return pulumi.get(self, "port")
 
 
-@pulumi.output_type
-class PublisherInfoResponse(dict):
-    """
-    Represents the publisher information of a process/rule
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "binaryName":
-            suggest = "binary_name"
-        elif key == "productName":
-            suggest = "product_name"
-        elif key == "publisherName":
-            suggest = "publisher_name"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in PublisherInfoResponse. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        PublisherInfoResponse.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        PublisherInfoResponse.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 binary_name: Optional[str] = None,
-                 product_name: Optional[str] = None,
-                 publisher_name: Optional[str] = None,
-                 version: Optional[str] = None):
-        """
-        Represents the publisher information of a process/rule
-        :param str binary_name: The "OriginalName" field taken from the file's version resource
-        :param str product_name: The product name taken from the file's version resource
-        :param 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 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[str]:
-        """
-        The "OriginalName" field taken from the file's version resource
-        """
-        return pulumi.get(self, "binary_name")
-
-    @property
-    @pulumi.getter(name="productName")
-    def product_name(self) -> Optional[str]:
-        """
-        The product name taken from the file's version resource
-        """
-        return pulumi.get(self, "product_name")
-
-    @property
-    @pulumi.getter(name="publisherName")
-    def publisher_name(self) -> Optional[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")
-
-    @property
-    @pulumi.getter
-    def version(self) -> Optional[str]:
-        """
-        The binary file version taken from the file's version resource
-        """
-        return pulumi.get(self, "version")
-
-
 @pulumi.output_type
 class RecommendationConfigurationPropertiesResponse(dict):
     """
@@ -9167,137 +8836,3 @@ class UserDefinedResourcesPropertiesResponse(dict):
         return pulumi.get(self, "query_subscriptions")
 
 
-@pulumi.output_type
-class UserRecommendationResponse(dict):
-    """
-    Represents a user that is recommended to be allowed for a certain rule
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "recommendationAction":
-            suggest = "recommendation_action"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in UserRecommendationResponse. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        UserRecommendationResponse.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        UserRecommendationResponse.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 recommendation_action: Optional[str] = None,
-                 username: Optional[str] = None):
-        """
-        Represents a user that is recommended to be allowed for a certain rule
-        :param str recommendation_action: The recommendation action of the machine or rule
-        :param 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[str]:
-        """
-        The recommendation action of the machine or rule
-        """
-        return pulumi.get(self, "recommendation_action")
-
-    @property
-    @pulumi.getter
-    def username(self) -> Optional[str]:
-        """
-        Represents a user that is recommended to be allowed for a certain rule
-        """
-        return pulumi.get(self, "username")
-
-
-@pulumi.output_type
-class VmRecommendationResponse(dict):
-    """
-    Represents a machine that is part of a machine group
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "configurationStatus":
-            suggest = "configuration_status"
-        elif key == "enforcementSupport":
-            suggest = "enforcement_support"
-        elif key == "recommendationAction":
-            suggest = "recommendation_action"
-        elif key == "resourceId":
-            suggest = "resource_id"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in VmRecommendationResponse. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        VmRecommendationResponse.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        VmRecommendationResponse.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 configuration_status: Optional[str] = None,
-                 enforcement_support: Optional[str] = None,
-                 recommendation_action: Optional[str] = None,
-                 resource_id: Optional[str] = None):
-        """
-        Represents a machine that is part of a machine group
-        :param str configuration_status: The configuration status of the machines group or machine or rule
-        :param str enforcement_support: The machine supportability of Enforce feature
-        :param str recommendation_action: The recommendation action of the machine or rule
-        :param 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[str]:
-        """
-        The configuration status of the machines group or machine or rule
-        """
-        return pulumi.get(self, "configuration_status")
-
-    @property
-    @pulumi.getter(name="enforcementSupport")
-    def enforcement_support(self) -> Optional[str]:
-        """
-        The machine supportability of Enforce feature
-        """
-        return pulumi.get(self, "enforcement_support")
-
-    @property
-    @pulumi.getter(name="recommendationAction")
-    def recommendation_action(self) -> Optional[str]:
-        """
-        The recommendation action of the machine or rule
-        """
-        return pulumi.get(self, "recommendation_action")
-
-    @property
-    @pulumi.getter(name="resourceId")
-    def resource_id(self) -> Optional[str]:
-        """
-        The full resource id of the machine
-        """
-        return pulumi.get(self, "resource_id")
-
-

pulumi_azure_native/security/v20200101/__init__.py

@@ -6,9 +6,7 @@ from ... import _utilities
 import typing
 # Export this package's modules as members:
 from ._enums import *
-from .adaptive_application_control import *
 from .assessment import *
-from .get_adaptive_application_control import *
 from .get_assessment import *
 from .get_jit_network_access_policy import *
 from .get_server_vulnerability_assessment import *