pulumi-newrelic 5.48.0a1752905769__py3-none-any.whl → 5.49.0__py3-none-any.whl

pulumi_newrelic/plugins/outputs.py

@@ -2,8 +2,7 @@
 # *** 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 builtins
-import copy
+import builtins as _builtins
 import warnings
 import sys
 import pulumi
@@ -57,15 +56,15 @@ class ApplicationSettingsErrorCollector(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 expected_error_classes: Optional[Sequence[builtins.str]] = None,
-                 expected_error_codes: Optional[Sequence[builtins.str]] = None,
-                 ignored_error_classes: Optional[Sequence[builtins.str]] = None,
-                 ignored_error_codes: Optional[Sequence[builtins.str]] = None):
+                 expected_error_classes: Optional[Sequence[_builtins.str]] = None,
+                 expected_error_codes: Optional[Sequence[_builtins.str]] = None,
+                 ignored_error_classes: Optional[Sequence[_builtins.str]] = None,
+                 ignored_error_codes: Optional[Sequence[_builtins.str]] = None):
         """
-        :param Sequence[builtins.str] expected_error_classes: A list of expected error classes.
-        :param Sequence[builtins.str] expected_error_codes: A list of expected error codes(any status code between 100-900).
-        :param Sequence[builtins.str] ignored_error_classes: A list of ignored error classes.
-        :param Sequence[builtins.str] ignored_error_codes: A list of ignored error codes(any status code between 100-900).
+        :param Sequence[_builtins.str] expected_error_classes: A list of expected error classes.
+        :param Sequence[_builtins.str] expected_error_codes: A list of expected error codes(any status code between 100-900).
+        :param Sequence[_builtins.str] ignored_error_classes: A list of ignored error classes.
+        :param Sequence[_builtins.str] ignored_error_codes: A list of ignored error codes(any status code between 100-900).
         """
         if expected_error_classes is not None:
             pulumi.set(__self__, "expected_error_classes", expected_error_classes)
@@ -76,33 +75,33 @@ class ApplicationSettingsErrorCollector(dict):
         if ignored_error_codes is not None:
             pulumi.set(__self__, "ignored_error_codes", ignored_error_codes)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="expectedErrorClasses")
-    def expected_error_classes(self) -> Optional[Sequence[builtins.str]]:
+    def expected_error_classes(self) -> Optional[Sequence[_builtins.str]]:
         """
         A list of expected error classes.
         """
         return pulumi.get(self, "expected_error_classes")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="expectedErrorCodes")
-    def expected_error_codes(self) -> Optional[Sequence[builtins.str]]:
+    def expected_error_codes(self) -> Optional[Sequence[_builtins.str]]:
         """
         A list of expected error codes(any status code between 100-900).
         """
         return pulumi.get(self, "expected_error_codes")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ignoredErrorClasses")
-    def ignored_error_classes(self) -> Optional[Sequence[builtins.str]]:
+    def ignored_error_classes(self) -> Optional[Sequence[_builtins.str]]:
         """
         A list of ignored error classes.
         """
         return pulumi.get(self, "ignored_error_classes")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ignoredErrorCodes")
-    def ignored_error_codes(self) -> Optional[Sequence[builtins.str]]:
+    def ignored_error_codes(self) -> Optional[Sequence[_builtins.str]]:
         """
         A list of ignored error codes(any status code between 100-900).
         """
@@ -137,15 +136,15 @@ class ApplicationSettingsTransactionTracer(dict):
     def __init__(__self__, *,
                  explain_query_plans: Optional[Sequence['outputs.ApplicationSettingsTransactionTracerExplainQueryPlan']] = None,
                  sql: Optional['outputs.ApplicationSettingsTransactionTracerSql'] = None,
-                 stack_trace_threshold_value: Optional[builtins.float] = None,
-                 transaction_threshold_type: Optional[builtins.str] = None,
-                 transaction_threshold_value: Optional[builtins.float] = None):
+                 stack_trace_threshold_value: Optional[_builtins.float] = None,
+                 transaction_threshold_type: Optional[_builtins.str] = None,
+                 transaction_threshold_value: Optional[_builtins.float] = None):
         """
         :param Sequence['ApplicationSettingsTransactionTracerExplainQueryPlanArgs'] explain_query_plans: Configuration block for query plans. Including this block enables the capture of query plans. The following arguments are supported:
         :param 'ApplicationSettingsTransactionTracerSqlArgs' sql: Configuration block for SQL logging.  Including this block enables SQL logging. The following arguments are supported:
-        :param builtins.float stack_trace_threshold_value: The response time threshold for collecting stack traces.
-        :param builtins.str transaction_threshold_type: The type of threshold for transactions. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
-        :param builtins.float transaction_threshold_value: The threshold value for transactions(in seconds).
+        :param _builtins.float stack_trace_threshold_value: The response time threshold for collecting stack traces.
+        :param _builtins.str transaction_threshold_type: The type of threshold for transactions. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
+        :param _builtins.float transaction_threshold_value: The threshold value for transactions(in seconds).
         """
         if explain_query_plans is not None:
             pulumi.set(__self__, "explain_query_plans", explain_query_plans)
@@ -158,7 +157,7 @@ class ApplicationSettingsTransactionTracer(dict):
         if transaction_threshold_value is not None:
             pulumi.set(__self__, "transaction_threshold_value", transaction_threshold_value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="explainQueryPlans")
     def explain_query_plans(self) -> Optional[Sequence['outputs.ApplicationSettingsTransactionTracerExplainQueryPlan']]:
         """
@@ -166,7 +165,7 @@ class ApplicationSettingsTransactionTracer(dict):
         """
         return pulumi.get(self, "explain_query_plans")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def sql(self) -> Optional['outputs.ApplicationSettingsTransactionTracerSql']:
         """
@@ -174,25 +173,25 @@ class ApplicationSettingsTransactionTracer(dict):
         """
         return pulumi.get(self, "sql")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="stackTraceThresholdValue")
-    def stack_trace_threshold_value(self) -> Optional[builtins.float]:
+    def stack_trace_threshold_value(self) -> Optional[_builtins.float]:
         """
         The response time threshold for collecting stack traces.
         """
         return pulumi.get(self, "stack_trace_threshold_value")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="transactionThresholdType")
-    def transaction_threshold_type(self) -> Optional[builtins.str]:
+    def transaction_threshold_type(self) -> Optional[_builtins.str]:
         """
         The type of threshold for transactions. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
         """
         return pulumi.get(self, "transaction_threshold_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="transactionThresholdValue")
-    def transaction_threshold_value(self) -> Optional[builtins.float]:
+    def transaction_threshold_value(self) -> Optional[_builtins.float]:
         """
         The threshold value for transactions(in seconds).
         """
@@ -221,28 +220,28 @@ class ApplicationSettingsTransactionTracerExplainQueryPlan(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 query_plan_threshold_type: Optional[builtins.str] = None,
-                 query_plan_threshold_value: Optional[builtins.float] = None):
+                 query_plan_threshold_type: Optional[_builtins.str] = None,
+                 query_plan_threshold_value: Optional[_builtins.float] = None):
         """
-        :param builtins.str query_plan_threshold_type: The type of threshold for query plans. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
-        :param builtins.float query_plan_threshold_value: The response time threshold for capturing query plans(in seconds).
+        :param _builtins.str query_plan_threshold_type: The type of threshold for query plans. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
+        :param _builtins.float query_plan_threshold_value: The response time threshold for capturing query plans(in seconds).
         """
         if query_plan_threshold_type is not None:
             pulumi.set(__self__, "query_plan_threshold_type", query_plan_threshold_type)
         if query_plan_threshold_value is not None:
             pulumi.set(__self__, "query_plan_threshold_value", query_plan_threshold_value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="queryPlanThresholdType")
-    def query_plan_threshold_type(self) -> Optional[builtins.str]:
+    def query_plan_threshold_type(self) -> Optional[_builtins.str]:
         """
         The type of threshold for query plans. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
         """
         return pulumi.get(self, "query_plan_threshold_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="queryPlanThresholdValue")
-    def query_plan_threshold_value(self) -> Optional[builtins.float]:
+    def query_plan_threshold_value(self) -> Optional[_builtins.float]:
         """
         The response time threshold for capturing query plans(in seconds).
         """
@@ -269,15 +268,15 @@ class ApplicationSettingsTransactionTracerSql(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 record_sql: builtins.str):
+                 record_sql: _builtins.str):
         """
-        :param builtins.str record_sql: The level of SQL recording. Valid values ar `OBFUSCATED`,`OFF`,`RAW` (Mandatory attribute when `sql` block is provided).
+        :param _builtins.str record_sql: The level of SQL recording. Valid values ar `OBFUSCATED`,`OFF`,`RAW` (Mandatory attribute when `sql` block is provided).
         """
         pulumi.set(__self__, "record_sql", record_sql)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="recordSql")
-    def record_sql(self) -> builtins.str:
+    def record_sql(self) -> _builtins.str:
         """
         The level of SQL recording. Valid values ar `OBFUSCATED`,`OFF`,`RAW` (Mandatory attribute when `sql` block is provided).
         """
@@ -287,15 +286,15 @@ class ApplicationSettingsTransactionTracerSql(dict):
 @pulumi.output_type
 class WorkloadEntitySearchQuery(dict):
     def __init__(__self__, *,
-                 query: builtins.str):
+                 query: _builtins.str):
         """
-        :param builtins.str query: A valid entity search query; empty, and null values are considered invalid.
+        :param _builtins.str query: A valid entity search query; empty, and null values are considered invalid.
         """
         pulumi.set(__self__, "query", query)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def query(self) -> builtins.str:
+    def query(self) -> _builtins.str:
         """
         A valid entity search query; empty, and null values are considered invalid.
         """
@@ -322,11 +321,11 @@ class WorkloadStatusConfigAutomatic(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 enabled: builtins.bool,
+                 enabled: _builtins.bool,
                  remaining_entities_rule: Optional['outputs.WorkloadStatusConfigAutomaticRemainingEntitiesRule'] = None,
                  rules: Optional[Sequence['outputs.WorkloadStatusConfigAutomaticRule']] = None):
         """
-        :param builtins.bool enabled: Whether the automatic status configuration is enabled or not.
+        :param _builtins.bool enabled: Whether the automatic status configuration is enabled or not.
         :param 'WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs' remaining_entities_rule: An additional meta-rule that can consider all entities that haven't been evaluated by any other rule.
         :param Sequence['WorkloadStatusConfigAutomaticRuleArgs'] rules: A list of rules.
         """
@@ -336,15 +335,15 @@ class WorkloadStatusConfigAutomatic(dict):
         if rules is not None:
             pulumi.set(__self__, "rules", rules)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def enabled(self) -> builtins.bool:
+    def enabled(self) -> _builtins.bool:
         """
         Whether the automatic status configuration is enabled or not.
         """
         return pulumi.get(self, "enabled")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="remainingEntitiesRule")
     def remaining_entities_rule(self) -> Optional['outputs.WorkloadStatusConfigAutomaticRemainingEntitiesRule']:
         """
@@ -352,7 +351,7 @@ class WorkloadStatusConfigAutomatic(dict):
         """
         return pulumi.get(self, "remaining_entities_rule")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def rules(self) -> Optional[Sequence['outputs.WorkloadStatusConfigAutomaticRule']]:
         """
@@ -387,7 +386,7 @@ class WorkloadStatusConfigAutomaticRemainingEntitiesRule(dict):
         """
         pulumi.set(__self__, "remaining_entities_rule_rollup", remaining_entities_rule_rollup)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="remainingEntitiesRuleRollup")
     def remaining_entities_rule_rollup(self) -> 'outputs.WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollup':
         """
@@ -420,15 +419,15 @@ class WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRol
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 group_by: builtins.str,
-                 strategy: builtins.str,
-                 threshold_type: Optional[builtins.str] = None,
-                 threshold_value: Optional[builtins.int] = None):
+                 group_by: _builtins.str,
+                 strategy: _builtins.str,
+                 threshold_type: Optional[_builtins.str] = None,
+                 threshold_value: Optional[_builtins.int] = None):
         """
-        :param builtins.str group_by: The grouping to be applied to the remaining entities.
-        :param builtins.str strategy: The rollup strategy that is applied to a group of entities.
-        :param builtins.str threshold_type: Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
-        :param builtins.int threshold_value: Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
+        :param _builtins.str group_by: The grouping to be applied to the remaining entities.
+        :param _builtins.str strategy: The rollup strategy that is applied to a group of entities.
+        :param _builtins.str threshold_type: Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
+        :param _builtins.int threshold_value: Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
         """
         pulumi.set(__self__, "group_by", group_by)
         pulumi.set(__self__, "strategy", strategy)
@@ -437,33 +436,33 @@ class WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRol
         if threshold_value is not None:
             pulumi.set(__self__, "threshold_value", threshold_value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="groupBy")
-    def group_by(self) -> builtins.str:
+    def group_by(self) -> _builtins.str:
         """
         The grouping to be applied to the remaining entities.
         """
         return pulumi.get(self, "group_by")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def strategy(self) -> builtins.str:
+    def strategy(self) -> _builtins.str:
         """
         The rollup strategy that is applied to a group of entities.
         """
         return pulumi.get(self, "strategy")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="thresholdType")
-    def threshold_type(self) -> Optional[builtins.str]:
+    def threshold_type(self) -> Optional[_builtins.str]:
         """
         Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
         """
         return pulumi.get(self, "threshold_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="thresholdValue")
-    def threshold_value(self) -> Optional[builtins.int]:
+    def threshold_value(self) -> Optional[_builtins.int]:
         """
         Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
         """
@@ -493,11 +492,11 @@ class WorkloadStatusConfigAutomaticRule(dict):
 
     def __init__(__self__, *,
                  rollup: 'outputs.WorkloadStatusConfigAutomaticRuleRollup',
-                 entity_guids: Optional[Sequence[builtins.str]] = None,
+                 entity_guids: Optional[Sequence[_builtins.str]] = None,
                  nrql_queries: Optional[Sequence['outputs.WorkloadStatusConfigAutomaticRuleNrqlQuery']] = None):
         """
         :param 'WorkloadStatusConfigAutomaticRuleRollupArgs' rollup: The input object used to represent a rollup strategy. See Nested rollup blocks below for details.
-        :param Sequence[builtins.str] entity_guids: A list of entity GUIDs composing the rule. At least one of `entity_guids` or `nrql_query` must be defined.
+        :param Sequence[_builtins.str] entity_guids: A list of entity GUIDs composing the rule. At least one of `entity_guids` or `nrql_query` must be defined.
         :param Sequence['WorkloadStatusConfigAutomaticRuleNrqlQueryArgs'] nrql_queries: A list of entity search queries used to retrieve the entities that compose the rule. See Nested nrql_query blocks below for details. At least one of `entity_guids` or `nrql_query` must be defined.
         """
         pulumi.set(__self__, "rollup", rollup)
@@ -506,7 +505,7 @@ class WorkloadStatusConfigAutomaticRule(dict):
         if nrql_queries is not None:
             pulumi.set(__self__, "nrql_queries", nrql_queries)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def rollup(self) -> 'outputs.WorkloadStatusConfigAutomaticRuleRollup':
         """
@@ -514,15 +513,15 @@ class WorkloadStatusConfigAutomaticRule(dict):
         """
         return pulumi.get(self, "rollup")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="entityGuids")
-    def entity_guids(self) -> Optional[Sequence[builtins.str]]:
+    def entity_guids(self) -> Optional[Sequence[_builtins.str]]:
         """
         A list of entity GUIDs composing the rule. At least one of `entity_guids` or `nrql_query` must be defined.
         """
         return pulumi.get(self, "entity_guids")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="nrqlQueries")
     def nrql_queries(self) -> Optional[Sequence['outputs.WorkloadStatusConfigAutomaticRuleNrqlQuery']]:
         """
@@ -534,15 +533,15 @@ class WorkloadStatusConfigAutomaticRule(dict):
 @pulumi.output_type
 class WorkloadStatusConfigAutomaticRuleNrqlQuery(dict):
     def __init__(__self__, *,
-                 query: builtins.str):
+                 query: _builtins.str):
         """
-        :param builtins.str query: The entity search query that is used to perform the search of a group of entities.
+        :param _builtins.str query: The entity search query that is used to perform the search of a group of entities.
         """
         pulumi.set(__self__, "query", query)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def query(self) -> builtins.str:
+    def query(self) -> _builtins.str:
         """
         The entity search query that is used to perform the search of a group of entities.
         """
@@ -571,13 +570,13 @@ class WorkloadStatusConfigAutomaticRuleRollup(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 strategy: builtins.str,
-                 threshold_type: Optional[builtins.str] = None,
-                 threshold_value: Optional[builtins.int] = None):
+                 strategy: _builtins.str,
+                 threshold_type: Optional[_builtins.str] = None,
+                 threshold_value: Optional[_builtins.int] = None):
         """
-        :param builtins.str strategy: The rollup strategy that is applied to a group of entities.
-        :param builtins.str threshold_type: Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
-        :param builtins.int threshold_value: Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
+        :param _builtins.str strategy: The rollup strategy that is applied to a group of entities.
+        :param _builtins.str threshold_type: Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
+        :param _builtins.int threshold_value: Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
         """
         pulumi.set(__self__, "strategy", strategy)
         if threshold_type is not None:
@@ -585,25 +584,25 @@ class WorkloadStatusConfigAutomaticRuleRollup(dict):
         if threshold_value is not None:
             pulumi.set(__self__, "threshold_value", threshold_value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def strategy(self) -> builtins.str:
+    def strategy(self) -> _builtins.str:
         """
         The rollup strategy that is applied to a group of entities.
         """
         return pulumi.get(self, "strategy")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="thresholdType")
-    def threshold_type(self) -> Optional[builtins.str]:
+    def threshold_type(self) -> Optional[_builtins.str]:
         """
         Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
         """
         return pulumi.get(self, "threshold_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="thresholdValue")
-    def threshold_value(self) -> Optional[builtins.int]:
+    def threshold_value(self) -> Optional[_builtins.int]:
         """
         Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
         """
@@ -613,15 +612,15 @@ class WorkloadStatusConfigAutomaticRuleRollup(dict):
 @pulumi.output_type
 class WorkloadStatusConfigStatic(dict):
     def __init__(__self__, *,
-                 enabled: builtins.bool,
-                 status: builtins.str,
-                 description: Optional[builtins.str] = None,
-                 summary: Optional[builtins.str] = None):
+                 enabled: _builtins.bool,
+                 status: _builtins.str,
+                 description: Optional[_builtins.str] = None,
+                 summary: Optional[_builtins.str] = None):
         """
-        :param builtins.bool enabled: Whether the static status configuration is enabled or not.
-        :param builtins.str status: The status of the workload.
-        :param builtins.str description: Relevant information about the workload.
-        :param builtins.str summary: A short description of the status of the workload.
+        :param _builtins.bool enabled: Whether the static status configuration is enabled or not.
+        :param _builtins.str status: The status of the workload.
+        :param _builtins.str description: Relevant information about the workload.
+        :param _builtins.str summary: A short description of the status of the workload.
         """
         pulumi.set(__self__, "enabled", enabled)
         pulumi.set(__self__, "status", status)
@@ -630,33 +629,33 @@ class WorkloadStatusConfigStatic(dict):
         if summary is not None:
             pulumi.set(__self__, "summary", summary)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def enabled(self) -> builtins.bool:
+    def enabled(self) -> _builtins.bool:
         """
         Whether the static status configuration is enabled or not.
         """
         return pulumi.get(self, "enabled")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def status(self) -> builtins.str:
+    def status(self) -> _builtins.str:
         """
         The status of the workload.
         """
         return pulumi.get(self, "status")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def description(self) -> Optional[builtins.str]:
+    def description(self) -> Optional[_builtins.str]:
         """
         Relevant information about the workload.
         """
         return pulumi.get(self, "description")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def summary(self) -> Optional[builtins.str]:
+    def summary(self) -> Optional[_builtins.str]:
         """
         A short description of the status of the workload.
         """