pulumi-azure-native 2.78.0a1734184513__py3-none-any.whl → 2.79.0__py3-none-any.whl

pulumi_azure_native/{alertsmanagement/v20240301preview/alert_processing_rule_by_name.py → compute/v20241104/cloud_service.py}

@@ -17,39 +17,43 @@ from . import outputs
 from ._enums import *
 from ._inputs import *
 
-__all__ = ['AlertProcessingRuleByNameArgs', 'AlertProcessingRuleByName']
+__all__ = ['CloudServiceArgs', 'CloudService']
 
 @pulumi.input_type
-class AlertProcessingRuleByNameArgs:
+class CloudServiceArgs:
     def __init__(__self__, *,
                  resource_group_name: pulumi.Input[str],
-                 alert_processing_rule_name: Optional[pulumi.Input[str]] = None,
+                 cloud_service_name: Optional[pulumi.Input[str]] = None,
                  location: Optional[pulumi.Input[str]] = None,
-                 properties: Optional[pulumi.Input['AlertProcessingRulePropertiesArgs']] = None,
-                 tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
+                 properties: Optional[pulumi.Input['CloudServicePropertiesArgs']] = None,
+                 tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
         """
-        The set of arguments for constructing a AlertProcessingRuleByName resource.
-        :param pulumi.Input[str] resource_group_name: Resource group name where the resource is created.
-        :param pulumi.Input[str] alert_processing_rule_name: The name of the alert processing rule that needs to be created/updated.
-        :param pulumi.Input[str] location: Resource location
-        :param pulumi.Input['AlertProcessingRulePropertiesArgs'] properties: Alert processing rule properties.
-        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: Resource tags
+        The set of arguments for constructing a CloudService resource.
+        :param pulumi.Input[str] resource_group_name: Name of the resource group.
+        :param pulumi.Input[str] cloud_service_name: Name of the cloud service.
+        :param pulumi.Input[str] location: Resource location.
+        :param pulumi.Input['CloudServicePropertiesArgs'] properties: Cloud service properties
+        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: Resource tags.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] zones: List of logical availability zone of the resource. List should contain only 1 zone where cloud service should be provisioned. This field is optional.
         """
         pulumi.set(__self__, "resource_group_name", resource_group_name)
-        if alert_processing_rule_name is not None:
-            pulumi.set(__self__, "alert_processing_rule_name", alert_processing_rule_name)
+        if cloud_service_name is not None:
+            pulumi.set(__self__, "cloud_service_name", cloud_service_name)
         if location is not None:
             pulumi.set(__self__, "location", location)
         if properties is not None:
             pulumi.set(__self__, "properties", properties)
         if tags is not None:
             pulumi.set(__self__, "tags", tags)
+        if zones is not None:
+            pulumi.set(__self__, "zones", zones)
 
     @property
     @pulumi.getter(name="resourceGroupName")
     def resource_group_name(self) -> pulumi.Input[str]:
         """
-        Resource group name where the resource is created.
+        Name of the resource group.
         """
         return pulumi.get(self, "resource_group_name")
 
@@ -58,22 +62,22 @@ class AlertProcessingRuleByNameArgs:
         pulumi.set(self, "resource_group_name", value)
 
     @property
-    @pulumi.getter(name="alertProcessingRuleName")
-    def alert_processing_rule_name(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter(name="cloudServiceName")
+    def cloud_service_name(self) -> Optional[pulumi.Input[str]]:
         """
-        The name of the alert processing rule that needs to be created/updated.
+        Name of the cloud service.
         """
-        return pulumi.get(self, "alert_processing_rule_name")
+        return pulumi.get(self, "cloud_service_name")
 
-    @alert_processing_rule_name.setter
-    def alert_processing_rule_name(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "alert_processing_rule_name", value)
+    @cloud_service_name.setter
+    def cloud_service_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "cloud_service_name", value)
 
     @property
     @pulumi.getter
     def location(self) -> Optional[pulumi.Input[str]]:
         """
-        Resource location
+        Resource location.
         """
         return pulumi.get(self, "location")
 
@@ -83,21 +87,21 @@ class AlertProcessingRuleByNameArgs:
 
     @property
     @pulumi.getter
-    def properties(self) -> Optional[pulumi.Input['AlertProcessingRulePropertiesArgs']]:
+    def properties(self) -> Optional[pulumi.Input['CloudServicePropertiesArgs']]:
         """
-        Alert processing rule properties.
+        Cloud service properties
         """
         return pulumi.get(self, "properties")
 
     @properties.setter
-    def properties(self, value: Optional[pulumi.Input['AlertProcessingRulePropertiesArgs']]):
+    def properties(self, value: Optional[pulumi.Input['CloudServicePropertiesArgs']]):
         pulumi.set(self, "properties", value)
 
     @property
     @pulumi.getter
     def tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
         """
-        Resource tags
+        Resource tags.
         """
         return pulumi.get(self, "tags")
 
@@ -105,45 +109,59 @@ class AlertProcessingRuleByNameArgs:
     def tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
         pulumi.set(self, "tags", value)
 
+    @property
+    @pulumi.getter
+    def zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        List of logical availability zone of the resource. List should contain only 1 zone where cloud service should be provisioned. This field is optional.
+        """
+        return pulumi.get(self, "zones")
+
+    @zones.setter
+    def zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "zones", value)
 
-class AlertProcessingRuleByName(pulumi.CustomResource):
+
+class CloudService(pulumi.CustomResource):
     @overload
     def __init__(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
-                 alert_processing_rule_name: Optional[pulumi.Input[str]] = None,
+                 cloud_service_name: Optional[pulumi.Input[str]] = None,
                  location: Optional[pulumi.Input[str]] = None,
-                 properties: Optional[pulumi.Input[Union['AlertProcessingRulePropertiesArgs', 'AlertProcessingRulePropertiesArgsDict']]] = None,
+                 properties: Optional[pulumi.Input[Union['CloudServicePropertiesArgs', 'CloudServicePropertiesArgsDict']]] = None,
                  resource_group_name: Optional[pulumi.Input[str]] = None,
                  tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  __props__=None):
         """
-        Alert processing rule object containing target scopes, conditions and scheduling logic.
+        Describes the cloud service.
 
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
-        :param pulumi.Input[str] alert_processing_rule_name: The name of the alert processing rule that needs to be created/updated.
-        :param pulumi.Input[str] location: Resource location
-        :param pulumi.Input[Union['AlertProcessingRulePropertiesArgs', 'AlertProcessingRulePropertiesArgsDict']] properties: Alert processing rule properties.
-        :param pulumi.Input[str] resource_group_name: Resource group name where the resource is created.
-        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: Resource tags
+        :param pulumi.Input[str] cloud_service_name: Name of the cloud service.
+        :param pulumi.Input[str] location: Resource location.
+        :param pulumi.Input[Union['CloudServicePropertiesArgs', 'CloudServicePropertiesArgsDict']] properties: Cloud service properties
+        :param pulumi.Input[str] resource_group_name: Name of the resource group.
+        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: Resource tags.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] zones: List of logical availability zone of the resource. List should contain only 1 zone where cloud service should be provisioned. This field is optional.
         """
         ...
     @overload
     def __init__(__self__,
                  resource_name: str,
-                 args: AlertProcessingRuleByNameArgs,
+                 args: CloudServiceArgs,
                  opts: Optional[pulumi.ResourceOptions] = None):
         """
-        Alert processing rule object containing target scopes, conditions and scheduling logic.
+        Describes the cloud service.
 
         :param str resource_name: The name of the resource.
-        :param AlertProcessingRuleByNameArgs args: The arguments to use to populate this resource's properties.
+        :param CloudServiceArgs args: The arguments to use to populate this resource's properties.
         :param pulumi.ResourceOptions opts: Options for the resource.
         """
         ...
     def __init__(__self__, resource_name: str, *args, **kwargs):
-        resource_args, opts = _utilities.get_resource_args_opts(AlertProcessingRuleByNameArgs, pulumi.ResourceOptions, *args, **kwargs)
+        resource_args, opts = _utilities.get_resource_args_opts(CloudServiceArgs, pulumi.ResourceOptions, *args, **kwargs)
         if resource_args is not None:
             __self__._internal_init(resource_name, opts, **resource_args.__dict__)
         else:
@@ -152,11 +170,12 @@ class AlertProcessingRuleByName(pulumi.CustomResource):
     def _internal_init(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
-                 alert_processing_rule_name: Optional[pulumi.Input[str]] = None,
+                 cloud_service_name: Optional[pulumi.Input[str]] = None,
                  location: Optional[pulumi.Input[str]] = None,
-                 properties: Optional[pulumi.Input[Union['AlertProcessingRulePropertiesArgs', 'AlertProcessingRulePropertiesArgsDict']]] = None,
+                 properties: Optional[pulumi.Input[Union['CloudServicePropertiesArgs', 'CloudServicePropertiesArgsDict']]] = None,
                  resource_group_name: Optional[pulumi.Input[str]] = None,
                  tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  __props__=None):
         opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
         if not isinstance(opts, pulumi.ResourceOptions):
@@ -164,22 +183,23 @@ class AlertProcessingRuleByName(pulumi.CustomResource):
         if opts.id is None:
             if __props__ is not None:
                 raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
-            __props__ = AlertProcessingRuleByNameArgs.__new__(AlertProcessingRuleByNameArgs)
+            __props__ = CloudServiceArgs.__new__(CloudServiceArgs)
 
-            __props__.__dict__["alert_processing_rule_name"] = alert_processing_rule_name
+            __props__.__dict__["cloud_service_name"] = cloud_service_name
             __props__.__dict__["location"] = location
             __props__.__dict__["properties"] = properties
             if resource_group_name is None and not opts.urn:
                 raise TypeError("Missing required property 'resource_group_name'")
             __props__.__dict__["resource_group_name"] = resource_group_name
             __props__.__dict__["tags"] = tags
+            __props__.__dict__["zones"] = zones
             __props__.__dict__["name"] = None
             __props__.__dict__["system_data"] = None
             __props__.__dict__["type"] = None
-        alias_opts = pulumi.ResourceOptions(aliases=[pulumi.Alias(type_="azure-native:alertsmanagement:AlertProcessingRuleByName"), pulumi.Alias(type_="azure-native:alertsmanagement/v20181102privatepreview:AlertProcessingRuleByName"), pulumi.Alias(type_="azure-native:alertsmanagement/v20190505preview:AlertProcessingRuleByName"), pulumi.Alias(type_="azure-native:alertsmanagement/v20210808:AlertProcessingRuleByName"), pulumi.Alias(type_="azure-native:alertsmanagement/v20210808preview:AlertProcessingRuleByName"), pulumi.Alias(type_="azure-native:alertsmanagement/v20230501preview:AlertProcessingRuleByName")])
+        alias_opts = pulumi.ResourceOptions(aliases=[pulumi.Alias(type_="azure-native:compute:CloudService"), pulumi.Alias(type_="azure-native:compute/v20201001preview:CloudService"), pulumi.Alias(type_="azure-native:compute/v20210301:CloudService"), pulumi.Alias(type_="azure-native:compute/v20220404:CloudService"), pulumi.Alias(type_="azure-native:compute/v20220904:CloudService")])
         opts = pulumi.ResourceOptions.merge(opts, alias_opts)
-        super(AlertProcessingRuleByName, __self__).__init__(
-            'azure-native:alertsmanagement/v20240301preview:AlertProcessingRuleByName',
+        super(CloudService, __self__).__init__(
+            'azure-native:compute/v20241104:CloudService',
             resource_name,
             __props__,
             opts)
@@ -187,9 +207,9 @@ class AlertProcessingRuleByName(pulumi.CustomResource):
     @staticmethod
     def get(resource_name: str,
             id: pulumi.Input[str],
-            opts: Optional[pulumi.ResourceOptions] = None) -> 'AlertProcessingRuleByName':
+            opts: Optional[pulumi.ResourceOptions] = None) -> 'CloudService':
         """
-        Get an existing AlertProcessingRuleByName resource's state with the given name, id, and optional extra
+        Get an existing CloudService resource's state with the given name, id, and optional extra
         properties used to qualify the lookup.
 
         :param str resource_name: The unique name of the resulting resource.
@@ -198,7 +218,7 @@ class AlertProcessingRuleByName(pulumi.CustomResource):
         """
         opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
 
-        __props__ = AlertProcessingRuleByNameArgs.__new__(AlertProcessingRuleByNameArgs)
+        __props__ = CloudServiceArgs.__new__(CloudServiceArgs)
 
         __props__.__dict__["location"] = None
         __props__.__dict__["name"] = None
@@ -206,13 +226,14 @@ class AlertProcessingRuleByName(pulumi.CustomResource):
         __props__.__dict__["system_data"] = None
         __props__.__dict__["tags"] = None
         __props__.__dict__["type"] = None
-        return AlertProcessingRuleByName(resource_name, opts=opts, __props__=__props__)
+        __props__.__dict__["zones"] = None
+        return CloudService(resource_name, opts=opts, __props__=__props__)
 
     @property
     @pulumi.getter
     def location(self) -> pulumi.Output[str]:
         """
-        Resource location
+        Resource location.
         """
         return pulumi.get(self, "location")
 
@@ -220,23 +241,23 @@ class AlertProcessingRuleByName(pulumi.CustomResource):
     @pulumi.getter
     def name(self) -> pulumi.Output[str]:
         """
-        Azure resource name
+        Resource name.
         """
         return pulumi.get(self, "name")
 
     @property
     @pulumi.getter
-    def properties(self) -> pulumi.Output['outputs.AlertProcessingRulePropertiesResponse']:
+    def properties(self) -> pulumi.Output['outputs.CloudServicePropertiesResponse']:
         """
-        Alert processing rule properties.
+        Cloud service properties
         """
         return pulumi.get(self, "properties")
 
     @property
     @pulumi.getter(name="systemData")
-    def system_data(self) -> pulumi.Output['outputs.SystemDataResponse']:
+    def system_data(self) -> pulumi.Output[Optional['outputs.SystemDataResponse']]:
         """
-        Alert processing rule system data.
+        The system meta data relating to this resource.
         """
         return pulumi.get(self, "system_data")
 
@@ -244,7 +265,7 @@ class AlertProcessingRuleByName(pulumi.CustomResource):
     @pulumi.getter
     def tags(self) -> pulumi.Output[Optional[Mapping[str, str]]]:
         """
-        Resource tags
+        Resource tags.
         """
         return pulumi.get(self, "tags")
 
@@ -252,7 +273,15 @@ class AlertProcessingRuleByName(pulumi.CustomResource):
     @pulumi.getter
     def type(self) -> pulumi.Output[str]:
         """
-        Azure resource type
+        Resource type.
         """
         return pulumi.get(self, "type")
 
+    @property
+    @pulumi.getter
+    def zones(self) -> pulumi.Output[Optional[Sequence[str]]]:
+        """
+        List of logical availability zone of the resource. List should contain only 1 zone where cloud service should be provisioned. This field is optional.
+        """
+        return pulumi.get(self, "zones")
+

pulumi_azure_native/{alertsmanagement/v20240301preview/get_alert_processing_rule_by_name.py → compute/v20241104/get_cloud_service.py}

@@ -16,18 +16,18 @@ from ... import _utilities
 from . import outputs
 
 __all__ = [
-    'GetAlertProcessingRuleByNameResult',
-    'AwaitableGetAlertProcessingRuleByNameResult',
-    'get_alert_processing_rule_by_name',
-    'get_alert_processing_rule_by_name_output',
+    'GetCloudServiceResult',
+    'AwaitableGetCloudServiceResult',
+    'get_cloud_service',
+    'get_cloud_service_output',
 ]
 
 @pulumi.output_type
-class GetAlertProcessingRuleByNameResult:
+class GetCloudServiceResult:
     """
-    Alert processing rule object containing target scopes, conditions and scheduling logic.
+    Describes the cloud service.
     """
-    def __init__(__self__, id=None, location=None, name=None, properties=None, system_data=None, tags=None, type=None):
+    def __init__(__self__, id=None, location=None, name=None, properties=None, system_data=None, tags=None, type=None, zones=None):
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
         pulumi.set(__self__, "id", id)
@@ -49,12 +49,15 @@ class GetAlertProcessingRuleByNameResult:
         if type and not isinstance(type, str):
             raise TypeError("Expected argument 'type' to be a str")
         pulumi.set(__self__, "type", type)
+        if zones and not isinstance(zones, list):
+            raise TypeError("Expected argument 'zones' to be a list")
+        pulumi.set(__self__, "zones", zones)
 
     @property
     @pulumi.getter
     def id(self) -> str:
         """
-        Azure resource Id
+        Resource Id.
         """
         return pulumi.get(self, "id")
 
@@ -62,7 +65,7 @@ class GetAlertProcessingRuleByNameResult:
     @pulumi.getter
     def location(self) -> str:
         """
-        Resource location
+        Resource location.
         """
         return pulumi.get(self, "location")
 
@@ -70,23 +73,23 @@ class GetAlertProcessingRuleByNameResult:
     @pulumi.getter
     def name(self) -> str:
         """
-        Azure resource name
+        Resource name.
         """
         return pulumi.get(self, "name")
 
     @property
     @pulumi.getter
-    def properties(self) -> 'outputs.AlertProcessingRulePropertiesResponse':
+    def properties(self) -> 'outputs.CloudServicePropertiesResponse':
         """
-        Alert processing rule properties.
+        Cloud service properties
         """
         return pulumi.get(self, "properties")
 
     @property
     @pulumi.getter(name="systemData")
-    def system_data(self) -> 'outputs.SystemDataResponse':
+    def system_data(self) -> Optional['outputs.SystemDataResponse']:
         """
-        Alert processing rule system data.
+        The system meta data relating to this resource.
         """
         return pulumi.get(self, "system_data")
 
@@ -94,7 +97,7 @@ class GetAlertProcessingRuleByNameResult:
     @pulumi.getter
     def tags(self) -> Optional[Mapping[str, str]]:
         """
-        Resource tags
+        Resource tags.
         """
         return pulumi.get(self, "tags")
 
@@ -102,70 +105,81 @@ class GetAlertProcessingRuleByNameResult:
     @pulumi.getter
     def type(self) -> str:
         """
-        Azure resource type
+        Resource type.
         """
         return pulumi.get(self, "type")
 
+    @property
+    @pulumi.getter
+    def zones(self) -> Optional[Sequence[str]]:
+        """
+        List of logical availability zone of the resource. List should contain only 1 zone where cloud service should be provisioned. This field is optional.
+        """
+        return pulumi.get(self, "zones")
+
 
-class AwaitableGetAlertProcessingRuleByNameResult(GetAlertProcessingRuleByNameResult):
+class AwaitableGetCloudServiceResult(GetCloudServiceResult):
     # pylint: disable=using-constant-test
     def __await__(self):
         if False:
             yield self
-        return GetAlertProcessingRuleByNameResult(
+        return GetCloudServiceResult(
             id=self.id,
             location=self.location,
             name=self.name,
             properties=self.properties,
             system_data=self.system_data,
             tags=self.tags,
-            type=self.type)
+            type=self.type,
+            zones=self.zones)
 
 
-def get_alert_processing_rule_by_name(alert_processing_rule_name: Optional[str] = None,
-                                      resource_group_name: Optional[str] = None,
-                                      opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetAlertProcessingRuleByNameResult:
+def get_cloud_service(cloud_service_name: Optional[str] = None,
+                      resource_group_name: Optional[str] = None,
+                      opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetCloudServiceResult:
     """
-    Get an alert processing rule by name.
+    Display information about a cloud service.
 
 
-    :param str alert_processing_rule_name: The name of the alert processing rule that needs to be fetched.
-    :param str resource_group_name: Resource group name where the resource is created.
+    :param str cloud_service_name: Name of the cloud service.
+    :param str resource_group_name: Name of the resource group.
     """
     __args__ = dict()
-    __args__['alertProcessingRuleName'] = alert_processing_rule_name
+    __args__['cloudServiceName'] = cloud_service_name
     __args__['resourceGroupName'] = resource_group_name
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
-    __ret__ = pulumi.runtime.invoke('azure-native:alertsmanagement/v20240301preview:getAlertProcessingRuleByName', __args__, opts=opts, typ=GetAlertProcessingRuleByNameResult).value
+    __ret__ = pulumi.runtime.invoke('azure-native:compute/v20241104:getCloudService', __args__, opts=opts, typ=GetCloudServiceResult).value
 
-    return AwaitableGetAlertProcessingRuleByNameResult(
+    return AwaitableGetCloudServiceResult(
         id=pulumi.get(__ret__, 'id'),
         location=pulumi.get(__ret__, 'location'),
         name=pulumi.get(__ret__, 'name'),
         properties=pulumi.get(__ret__, 'properties'),
         system_data=pulumi.get(__ret__, 'system_data'),
         tags=pulumi.get(__ret__, 'tags'),
-        type=pulumi.get(__ret__, 'type'))
-def get_alert_processing_rule_by_name_output(alert_processing_rule_name: Optional[pulumi.Input[str]] = None,
-                                             resource_group_name: Optional[pulumi.Input[str]] = None,
-                                             opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetAlertProcessingRuleByNameResult]:
+        type=pulumi.get(__ret__, 'type'),
+        zones=pulumi.get(__ret__, 'zones'))
+def get_cloud_service_output(cloud_service_name: Optional[pulumi.Input[str]] = None,
+                             resource_group_name: Optional[pulumi.Input[str]] = None,
+                             opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetCloudServiceResult]:
     """
-    Get an alert processing rule by name.
+    Display information about a cloud service.
 
 
-    :param str alert_processing_rule_name: The name of the alert processing rule that needs to be fetched.
-    :param str resource_group_name: Resource group name where the resource is created.
+    :param str cloud_service_name: Name of the cloud service.
+    :param str resource_group_name: Name of the resource group.
     """
     __args__ = dict()
-    __args__['alertProcessingRuleName'] = alert_processing_rule_name
+    __args__['cloudServiceName'] = cloud_service_name
     __args__['resourceGroupName'] = resource_group_name
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
-    __ret__ = pulumi.runtime.invoke_output('azure-native:alertsmanagement/v20240301preview:getAlertProcessingRuleByName', __args__, opts=opts, typ=GetAlertProcessingRuleByNameResult)
-    return __ret__.apply(lambda __response__: GetAlertProcessingRuleByNameResult(
+    __ret__ = pulumi.runtime.invoke_output('azure-native:compute/v20241104:getCloudService', __args__, opts=opts, typ=GetCloudServiceResult)
+    return __ret__.apply(lambda __response__: GetCloudServiceResult(
         id=pulumi.get(__response__, 'id'),
         location=pulumi.get(__response__, 'location'),
         name=pulumi.get(__response__, 'name'),
         properties=pulumi.get(__response__, 'properties'),
         system_data=pulumi.get(__response__, 'system_data'),
         tags=pulumi.get(__response__, 'tags'),
-        type=pulumi.get(__response__, 'type')))
+        type=pulumi.get(__response__, 'type'),
+        zones=pulumi.get(__response__, 'zones')))