# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import builtins
import copy
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities

__all__ = [
    'ApplicationSettingsErrorCollectorArgs',
    'ApplicationSettingsErrorCollectorArgsDict',
    'ApplicationSettingsTransactionTracerArgs',
    'ApplicationSettingsTransactionTracerArgsDict',
    'ApplicationSettingsTransactionTracerExplainQueryPlanArgs',
    'ApplicationSettingsTransactionTracerExplainQueryPlanArgsDict',
    'ApplicationSettingsTransactionTracerSqlArgs',
    'ApplicationSettingsTransactionTracerSqlArgsDict',
    'WorkloadEntitySearchQueryArgs',
    'WorkloadEntitySearchQueryArgsDict',
    'WorkloadStatusConfigAutomaticArgs',
    'WorkloadStatusConfigAutomaticArgsDict',
    'WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs',
    'WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgsDict',
    'WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs',
    'WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgsDict',
    'WorkloadStatusConfigAutomaticRuleArgs',
    'WorkloadStatusConfigAutomaticRuleArgsDict',
    'WorkloadStatusConfigAutomaticRuleNrqlQueryArgs',
    'WorkloadStatusConfigAutomaticRuleNrqlQueryArgsDict',
    'WorkloadStatusConfigAutomaticRuleRollupArgs',
    'WorkloadStatusConfigAutomaticRuleRollupArgsDict',
    'WorkloadStatusConfigStaticArgs',
    'WorkloadStatusConfigStaticArgsDict',
]

MYPY = False

if not MYPY:
    class ApplicationSettingsErrorCollectorArgsDict(TypedDict):
        expected_error_classes: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        A list of expected error classes.
        """
        expected_error_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        A list of expected error codes(any status code between 100-900).
        """
        ignored_error_classes: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        A list of ignored error classes.
        """
        ignored_error_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        A list of ignored error codes(any status code between 100-900).
        """
elif False:
    ApplicationSettingsErrorCollectorArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ApplicationSettingsErrorCollectorArgs:
    def __init__(__self__, *,
                 expected_error_classes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 expected_error_codes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 ignored_error_classes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 ignored_error_codes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] expected_error_classes: A list of expected error classes.
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] expected_error_codes: A list of expected error codes(any status code between 100-900).
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ignored_error_classes: A list of ignored error classes.
        :param pulumi.Input[Sequence[pulumi.Input[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)
        if expected_error_codes is not None:
            pulumi.set(__self__, "expected_error_codes", expected_error_codes)
        if ignored_error_classes is not None:
            pulumi.set(__self__, "ignored_error_classes", ignored_error_classes)
        if ignored_error_codes is not None:
            pulumi.set(__self__, "ignored_error_codes", ignored_error_codes)

    @property
    @pulumi.getter(name="expectedErrorClasses")
    def expected_error_classes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        A list of expected error classes.
        """
        return pulumi.get(self, "expected_error_classes")

    @expected_error_classes.setter
    def expected_error_classes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "expected_error_classes", value)

    @property
    @pulumi.getter(name="expectedErrorCodes")
    def expected_error_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        A list of expected error codes(any status code between 100-900).
        """
        return pulumi.get(self, "expected_error_codes")

    @expected_error_codes.setter
    def expected_error_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "expected_error_codes", value)

    @property
    @pulumi.getter(name="ignoredErrorClasses")
    def ignored_error_classes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        A list of ignored error classes.
        """
        return pulumi.get(self, "ignored_error_classes")

    @ignored_error_classes.setter
    def ignored_error_classes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "ignored_error_classes", value)

    @property
    @pulumi.getter(name="ignoredErrorCodes")
    def ignored_error_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        A list of ignored error codes(any status code between 100-900).
        """
        return pulumi.get(self, "ignored_error_codes")

    @ignored_error_codes.setter
    def ignored_error_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "ignored_error_codes", value)


if not MYPY:
    class ApplicationSettingsTransactionTracerArgsDict(TypedDict):
        explain_query_plans: NotRequired[pulumi.Input[Sequence[pulumi.Input['ApplicationSettingsTransactionTracerExplainQueryPlanArgsDict']]]]
        """
        Configuration block for query plans. Including this block enables the capture of query plans. The following arguments are supported:
        """
        sql: NotRequired[pulumi.Input['ApplicationSettingsTransactionTracerSqlArgsDict']]
        """
        Configuration block for SQL logging.  Including this block enables SQL logging. The following arguments are supported:
        """
        stack_trace_threshold_value: NotRequired[pulumi.Input[builtins.float]]
        """
        The response time threshold for collecting stack traces.
        """
        transaction_threshold_type: NotRequired[pulumi.Input[builtins.str]]
        """
        The type of threshold for transactions. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
        """
        transaction_threshold_value: NotRequired[pulumi.Input[builtins.float]]
        """
        The threshold value for transactions(in seconds).
        """
elif False:
    ApplicationSettingsTransactionTracerArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ApplicationSettingsTransactionTracerArgs:
    def __init__(__self__, *,
                 explain_query_plans: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSettingsTransactionTracerExplainQueryPlanArgs']]]] = None,
                 sql: Optional[pulumi.Input['ApplicationSettingsTransactionTracerSqlArgs']] = None,
                 stack_trace_threshold_value: Optional[pulumi.Input[builtins.float]] = None,
                 transaction_threshold_type: Optional[pulumi.Input[builtins.str]] = None,
                 transaction_threshold_value: Optional[pulumi.Input[builtins.float]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ApplicationSettingsTransactionTracerExplainQueryPlanArgs']]] explain_query_plans: Configuration block for query plans. Including this block enables the capture of query plans. The following arguments are supported:
        :param pulumi.Input['ApplicationSettingsTransactionTracerSqlArgs'] sql: Configuration block for SQL logging.  Including this block enables SQL logging. The following arguments are supported:
        :param pulumi.Input[builtins.float] stack_trace_threshold_value: The response time threshold for collecting stack traces.
        :param pulumi.Input[builtins.str] transaction_threshold_type: The type of threshold for transactions. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
        :param pulumi.Input[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)
        if sql is not None:
            pulumi.set(__self__, "sql", sql)
        if stack_trace_threshold_value is not None:
            pulumi.set(__self__, "stack_trace_threshold_value", stack_trace_threshold_value)
        if transaction_threshold_type is not None:
            pulumi.set(__self__, "transaction_threshold_type", transaction_threshold_type)
        if transaction_threshold_value is not None:
            pulumi.set(__self__, "transaction_threshold_value", transaction_threshold_value)

    @property
    @pulumi.getter(name="explainQueryPlans")
    def explain_query_plans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSettingsTransactionTracerExplainQueryPlanArgs']]]]:
        """
        Configuration block for query plans. Including this block enables the capture of query plans. The following arguments are supported:
        """
        return pulumi.get(self, "explain_query_plans")

    @explain_query_plans.setter
    def explain_query_plans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSettingsTransactionTracerExplainQueryPlanArgs']]]]):
        pulumi.set(self, "explain_query_plans", value)

    @property
    @pulumi.getter
    def sql(self) -> Optional[pulumi.Input['ApplicationSettingsTransactionTracerSqlArgs']]:
        """
        Configuration block for SQL logging.  Including this block enables SQL logging. The following arguments are supported:
        """
        return pulumi.get(self, "sql")

    @sql.setter
    def sql(self, value: Optional[pulumi.Input['ApplicationSettingsTransactionTracerSqlArgs']]):
        pulumi.set(self, "sql", value)

    @property
    @pulumi.getter(name="stackTraceThresholdValue")
    def stack_trace_threshold_value(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        The response time threshold for collecting stack traces.
        """
        return pulumi.get(self, "stack_trace_threshold_value")

    @stack_trace_threshold_value.setter
    def stack_trace_threshold_value(self, value: Optional[pulumi.Input[builtins.float]]):
        pulumi.set(self, "stack_trace_threshold_value", value)

    @property
    @pulumi.getter(name="transactionThresholdType")
    def transaction_threshold_type(self) -> Optional[pulumi.Input[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")

    @transaction_threshold_type.setter
    def transaction_threshold_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "transaction_threshold_type", value)

    @property
    @pulumi.getter(name="transactionThresholdValue")
    def transaction_threshold_value(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        The threshold value for transactions(in seconds).
        """
        return pulumi.get(self, "transaction_threshold_value")

    @transaction_threshold_value.setter
    def transaction_threshold_value(self, value: Optional[pulumi.Input[builtins.float]]):
        pulumi.set(self, "transaction_threshold_value", value)


if not MYPY:
    class ApplicationSettingsTransactionTracerExplainQueryPlanArgsDict(TypedDict):
        query_plan_threshold_type: NotRequired[pulumi.Input[builtins.str]]
        """
        The type of threshold for query plans. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
        """
        query_plan_threshold_value: NotRequired[pulumi.Input[builtins.float]]
        """
        The response time threshold for capturing query plans(in seconds).
        """
elif False:
    ApplicationSettingsTransactionTracerExplainQueryPlanArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ApplicationSettingsTransactionTracerExplainQueryPlanArgs:
    def __init__(__self__, *,
                 query_plan_threshold_type: Optional[pulumi.Input[builtins.str]] = None,
                 query_plan_threshold_value: Optional[pulumi.Input[builtins.float]] = None):
        """
        :param pulumi.Input[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 pulumi.Input[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
    @pulumi.getter(name="queryPlanThresholdType")
    def query_plan_threshold_type(self) -> Optional[pulumi.Input[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")

    @query_plan_threshold_type.setter
    def query_plan_threshold_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "query_plan_threshold_type", value)

    @property
    @pulumi.getter(name="queryPlanThresholdValue")
    def query_plan_threshold_value(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        The response time threshold for capturing query plans(in seconds).
        """
        return pulumi.get(self, "query_plan_threshold_value")

    @query_plan_threshold_value.setter
    def query_plan_threshold_value(self, value: Optional[pulumi.Input[builtins.float]]):
        pulumi.set(self, "query_plan_threshold_value", value)


if not MYPY:
    class ApplicationSettingsTransactionTracerSqlArgsDict(TypedDict):
        record_sql: pulumi.Input[builtins.str]
        """
        The level of SQL recording. Valid values ar `OBFUSCATED`,`OFF`,`RAW` (Mandatory attribute when `sql` block is provided).
        """
elif False:
    ApplicationSettingsTransactionTracerSqlArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ApplicationSettingsTransactionTracerSqlArgs:
    def __init__(__self__, *,
                 record_sql: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[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
    @pulumi.getter(name="recordSql")
    def record_sql(self) -> pulumi.Input[builtins.str]:
        """
        The level of SQL recording. Valid values ar `OBFUSCATED`,`OFF`,`RAW` (Mandatory attribute when `sql` block is provided).
        """
        return pulumi.get(self, "record_sql")

    @record_sql.setter
    def record_sql(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "record_sql", value)


if not MYPY:
    class WorkloadEntitySearchQueryArgsDict(TypedDict):
        query: pulumi.Input[builtins.str]
        """
        A valid entity search query; empty, and null values are considered invalid.
        """
elif False:
    WorkloadEntitySearchQueryArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class WorkloadEntitySearchQueryArgs:
    def __init__(__self__, *,
                 query: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[builtins.str] query: A valid entity search query; empty, and null values are considered invalid.
        """
        pulumi.set(__self__, "query", query)

    @property
    @pulumi.getter
    def query(self) -> pulumi.Input[builtins.str]:
        """
        A valid entity search query; empty, and null values are considered invalid.
        """
        return pulumi.get(self, "query")

    @query.setter
    def query(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "query", value)


if not MYPY:
    class WorkloadStatusConfigAutomaticArgsDict(TypedDict):
        enabled: pulumi.Input[builtins.bool]
        """
        Whether the automatic status configuration is enabled or not.
        """
        remaining_entities_rule: NotRequired[pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgsDict']]
        """
        An additional meta-rule that can consider all entities that haven't been evaluated by any other rule.
        """
        rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleArgsDict']]]]
        """
        A list of rules.
        """
elif False:
    WorkloadStatusConfigAutomaticArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class WorkloadStatusConfigAutomaticArgs:
    def __init__(__self__, *,
                 enabled: pulumi.Input[builtins.bool],
                 remaining_entities_rule: Optional[pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs']] = None,
                 rules: Optional[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleArgs']]]] = None):
        """
        :param pulumi.Input[builtins.bool] enabled: Whether the automatic status configuration is enabled or not.
        :param pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs'] remaining_entities_rule: An additional meta-rule that can consider all entities that haven't been evaluated by any other rule.
        :param pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleArgs']]] rules: A list of rules.
        """
        pulumi.set(__self__, "enabled", enabled)
        if remaining_entities_rule is not None:
            pulumi.set(__self__, "remaining_entities_rule", remaining_entities_rule)
        if rules is not None:
            pulumi.set(__self__, "rules", rules)

    @property
    @pulumi.getter
    def enabled(self) -> pulumi.Input[builtins.bool]:
        """
        Whether the automatic status configuration is enabled or not.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: pulumi.Input[builtins.bool]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="remainingEntitiesRule")
    def remaining_entities_rule(self) -> Optional[pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs']]:
        """
        An additional meta-rule that can consider all entities that haven't been evaluated by any other rule.
        """
        return pulumi.get(self, "remaining_entities_rule")

    @remaining_entities_rule.setter
    def remaining_entities_rule(self, value: Optional[pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs']]):
        pulumi.set(self, "remaining_entities_rule", value)

    @property
    @pulumi.getter
    def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleArgs']]]]:
        """
        A list of rules.
        """
        return pulumi.get(self, "rules")

    @rules.setter
    def rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleArgs']]]]):
        pulumi.set(self, "rules", value)


if not MYPY:
    class WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgsDict(TypedDict):
        remaining_entities_rule_rollup: pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgsDict']
        """
        The input object used to represent a rollup strategy.
        """
elif False:
    WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs:
    def __init__(__self__, *,
                 remaining_entities_rule_rollup: pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs']):
        """
        :param pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs'] remaining_entities_rule_rollup: The input object used to represent a rollup strategy.
        """
        pulumi.set(__self__, "remaining_entities_rule_rollup", remaining_entities_rule_rollup)

    @property
    @pulumi.getter(name="remainingEntitiesRuleRollup")
    def remaining_entities_rule_rollup(self) -> pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs']:
        """
        The input object used to represent a rollup strategy.
        """
        return pulumi.get(self, "remaining_entities_rule_rollup")

    @remaining_entities_rule_rollup.setter
    def remaining_entities_rule_rollup(self, value: pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs']):
        pulumi.set(self, "remaining_entities_rule_rollup", value)


if not MYPY:
    class WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgsDict(TypedDict):
        group_by: pulumi.Input[builtins.str]
        """
        The grouping to be applied to the remaining entities.
        """
        strategy: pulumi.Input[builtins.str]
        """
        The rollup strategy that is applied to a group of entities.
        """
        threshold_type: NotRequired[pulumi.Input[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.
        """
        threshold_value: NotRequired[pulumi.Input[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.
        """
elif False:
    WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs:
    def __init__(__self__, *,
                 group_by: pulumi.Input[builtins.str],
                 strategy: pulumi.Input[builtins.str],
                 threshold_type: Optional[pulumi.Input[builtins.str]] = None,
                 threshold_value: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] group_by: The grouping to be applied to the remaining entities.
        :param pulumi.Input[builtins.str] strategy: The rollup strategy that is applied to a group of entities.
        :param pulumi.Input[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 pulumi.Input[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)
        if threshold_type is not None:
            pulumi.set(__self__, "threshold_type", threshold_type)
        if threshold_value is not None:
            pulumi.set(__self__, "threshold_value", threshold_value)

    @property
    @pulumi.getter(name="groupBy")
    def group_by(self) -> pulumi.Input[builtins.str]:
        """
        The grouping to be applied to the remaining entities.
        """
        return pulumi.get(self, "group_by")

    @group_by.setter
    def group_by(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "group_by", value)

    @property
    @pulumi.getter
    def strategy(self) -> pulumi.Input[builtins.str]:
        """
        The rollup strategy that is applied to a group of entities.
        """
        return pulumi.get(self, "strategy")

    @strategy.setter
    def strategy(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "strategy", value)

    @property
    @pulumi.getter(name="thresholdType")
    def threshold_type(self) -> Optional[pulumi.Input[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")

    @threshold_type.setter
    def threshold_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "threshold_type", value)

    @property
    @pulumi.getter(name="thresholdValue")
    def threshold_value(self) -> Optional[pulumi.Input[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.
        """
        return pulumi.get(self, "threshold_value")

    @threshold_value.setter
    def threshold_value(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "threshold_value", value)


if not MYPY:
    class WorkloadStatusConfigAutomaticRuleArgsDict(TypedDict):
        rollup: pulumi.Input['WorkloadStatusConfigAutomaticRuleRollupArgsDict']
        """
        The input object used to represent a rollup strategy. See Nested rollup blocks below for details.
        """
        entity_guids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        A list of entity GUIDs composing the rule. At least one of `entity_guids` or `nrql_query` must be defined.
        """
        nrql_queries: NotRequired[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleNrqlQueryArgsDict']]]]
        """
        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.
        """
elif False:
    WorkloadStatusConfigAutomaticRuleArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class WorkloadStatusConfigAutomaticRuleArgs:
    def __init__(__self__, *,
                 rollup: pulumi.Input['WorkloadStatusConfigAutomaticRuleRollupArgs'],
                 entity_guids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 nrql_queries: Optional[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleNrqlQueryArgs']]]] = None):
        """
        :param pulumi.Input['WorkloadStatusConfigAutomaticRuleRollupArgs'] rollup: The input object used to represent a rollup strategy. See Nested rollup blocks below for details.
        :param pulumi.Input[Sequence[pulumi.Input[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 pulumi.Input[Sequence[pulumi.Input['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)
        if entity_guids is not None:
            pulumi.set(__self__, "entity_guids", entity_guids)
        if nrql_queries is not None:
            pulumi.set(__self__, "nrql_queries", nrql_queries)

    @property
    @pulumi.getter
    def rollup(self) -> pulumi.Input['WorkloadStatusConfigAutomaticRuleRollupArgs']:
        """
        The input object used to represent a rollup strategy. See Nested rollup blocks below for details.
        """
        return pulumi.get(self, "rollup")

    @rollup.setter
    def rollup(self, value: pulumi.Input['WorkloadStatusConfigAutomaticRuleRollupArgs']):
        pulumi.set(self, "rollup", value)

    @property
    @pulumi.getter(name="entityGuids")
    def entity_guids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[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")

    @entity_guids.setter
    def entity_guids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "entity_guids", value)

    @property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleNrqlQueryArgs']]]]:
        """
        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.
        """
        return pulumi.get(self, "nrql_queries")

    @nrql_queries.setter
    def nrql_queries(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleNrqlQueryArgs']]]]):
        pulumi.set(self, "nrql_queries", value)


if not MYPY:
    class WorkloadStatusConfigAutomaticRuleNrqlQueryArgsDict(TypedDict):
        query: pulumi.Input[builtins.str]
        """
        The entity search query that is used to perform the search of a group of entities.
        """
elif False:
    WorkloadStatusConfigAutomaticRuleNrqlQueryArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class WorkloadStatusConfigAutomaticRuleNrqlQueryArgs:
    def __init__(__self__, *,
                 query: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[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
    @pulumi.getter
    def query(self) -> pulumi.Input[builtins.str]:
        """
        The entity search query that is used to perform the search of a group of entities.
        """
        return pulumi.get(self, "query")

    @query.setter
    def query(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "query", value)


if not MYPY:
    class WorkloadStatusConfigAutomaticRuleRollupArgsDict(TypedDict):
        strategy: pulumi.Input[builtins.str]
        """
        The rollup strategy that is applied to a group of entities.
        """
        threshold_type: NotRequired[pulumi.Input[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.
        """
        threshold_value: NotRequired[pulumi.Input[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.
        """
elif False:
    WorkloadStatusConfigAutomaticRuleRollupArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class WorkloadStatusConfigAutomaticRuleRollupArgs:
    def __init__(__self__, *,
                 strategy: pulumi.Input[builtins.str],
                 threshold_type: Optional[pulumi.Input[builtins.str]] = None,
                 threshold_value: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] strategy: The rollup strategy that is applied to a group of entities.
        :param pulumi.Input[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 pulumi.Input[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:
            pulumi.set(__self__, "threshold_type", threshold_type)
        if threshold_value is not None:
            pulumi.set(__self__, "threshold_value", threshold_value)

    @property
    @pulumi.getter
    def strategy(self) -> pulumi.Input[builtins.str]:
        """
        The rollup strategy that is applied to a group of entities.
        """
        return pulumi.get(self, "strategy")

    @strategy.setter
    def strategy(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "strategy", value)

    @property
    @pulumi.getter(name="thresholdType")
    def threshold_type(self) -> Optional[pulumi.Input[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")

    @threshold_type.setter
    def threshold_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "threshold_type", value)

    @property
    @pulumi.getter(name="thresholdValue")
    def threshold_value(self) -> Optional[pulumi.Input[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.
        """
        return pulumi.get(self, "threshold_value")

    @threshold_value.setter
    def threshold_value(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "threshold_value", value)


if not MYPY:
    class WorkloadStatusConfigStaticArgsDict(TypedDict):
        enabled: pulumi.Input[builtins.bool]
        """
        Whether the static status configuration is enabled or not.
        """
        status: pulumi.Input[builtins.str]
        """
        The status of the workload.
        """
        description: NotRequired[pulumi.Input[builtins.str]]
        """
        Relevant information about the workload.
        """
        summary: NotRequired[pulumi.Input[builtins.str]]
        """
        A short description of the status of the workload.
        """
elif False:
    WorkloadStatusConfigStaticArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class WorkloadStatusConfigStaticArgs:
    def __init__(__self__, *,
                 enabled: pulumi.Input[builtins.bool],
                 status: pulumi.Input[builtins.str],
                 description: Optional[pulumi.Input[builtins.str]] = None,
                 summary: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.bool] enabled: Whether the static status configuration is enabled or not.
        :param pulumi.Input[builtins.str] status: The status of the workload.
        :param pulumi.Input[builtins.str] description: Relevant information about the workload.
        :param pulumi.Input[builtins.str] summary: A short description of the status of the workload.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "status", status)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if summary is not None:
            pulumi.set(__self__, "summary", summary)

    @property
    @pulumi.getter
    def enabled(self) -> pulumi.Input[builtins.bool]:
        """
        Whether the static status configuration is enabled or not.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: pulumi.Input[builtins.bool]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter
    def status(self) -> pulumi.Input[builtins.str]:
        """
        The status of the workload.
        """
        return pulumi.get(self, "status")

    @status.setter
    def status(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "status", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Relevant information about the workload.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "description", value)

    @property
    @pulumi.getter
    def summary(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        A short description of the status of the workload.
        """
        return pulumi.get(self, "summary")

    @summary.setter
    def summary(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "summary", value)


