# 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 warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'DataMaskRuleTargetSelected',
    'DetectorRecipeDetectorRule',
    'DetectorRecipeDetectorRuleCandidateResponderRule',
    'DetectorRecipeDetectorRuleDetails',
    'DetectorRecipeDetectorRuleDetailsConfiguration',
    'DetectorRecipeDetectorRuleDetailsConfigurationValue',
    'DetectorRecipeEffectiveDetectorRule',
    'DetectorRecipeEffectiveDetectorRuleCandidateResponderRule',
    'DetectorRecipeEffectiveDetectorRuleDetails',
    'DetectorRecipeEffectiveDetectorRuleDetailsConfiguration',
    'DetectorRecipeEffectiveDetectorRuleDetailsConfigurationValue',
    'ResponderRecipeEffectiveResponderRule',
    'ResponderRecipeEffectiveResponderRuleDetails',
    'ResponderRecipeEffectiveResponderRuleDetailsConfiguration',
    'ResponderRecipeResponderRule',
    'ResponderRecipeResponderRuleDetails',
    'ResponderRecipeResponderRuleDetailsConfiguration',
    'TargetTargetDetectorRecipe',
    'TargetTargetDetectorRecipeDetectorRule',
    'TargetTargetDetectorRecipeDetectorRuleDetails',
    'TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroup',
    'TargetTargetDetectorRecipeDetectorRuleDetailsConfiguration',
    'TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValue',
    'TargetTargetDetectorRecipeEffectiveDetectorRule',
    'TargetTargetDetectorRecipeEffectiveDetectorRuleDetails',
    'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConditionGroup',
    'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfiguration',
    'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValue',
    'TargetTargetResponderRecipe',
    'TargetTargetResponderRecipeEffectiveResponderRule',
    'TargetTargetResponderRecipeEffectiveResponderRuleDetails',
    'TargetTargetResponderRecipeEffectiveResponderRuleDetailsConfiguration',
    'TargetTargetResponderRecipeResponderRule',
    'TargetTargetResponderRecipeResponderRuleDetails',
    'TargetTargetResponderRecipeResponderRuleDetailsConfiguration',
    'GetDataMaskRuleTargetSelectedResult',
    'GetDataMaskRulesDataMaskRuleCollectionResult',
    'GetDataMaskRulesDataMaskRuleCollectionItemResult',
    'GetDataMaskRulesDataMaskRuleCollectionItemTargetSelectedResult',
    'GetDataMaskRulesFilterResult',
    'GetDetectorRecipeDetectorRuleResult',
    'GetDetectorRecipeDetectorRuleCandidateResponderRuleResult',
    'GetDetectorRecipeDetectorRuleDetailsResult',
    'GetDetectorRecipeDetectorRuleDetailsConfigurationResult',
    'GetDetectorRecipeDetectorRuleDetailsConfigurationValueResult',
    'GetDetectorRecipeEffectiveDetectorRuleResult',
    'GetDetectorRecipeEffectiveDetectorRuleCandidateResponderRuleResult',
    'GetDetectorRecipeEffectiveDetectorRuleDetailsResult',
    'GetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationResult',
    'GetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValueResult',
    'GetDetectorRecipesDetectorRecipeCollectionResult',
    'GetDetectorRecipesDetectorRecipeCollectionItemResult',
    'GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleResult',
    'GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleCandidateResponderRuleResult',
    'GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleDetailsResult',
    'GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleDetailsConfigurationResult',
    'GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleDetailsConfigurationValueResult',
    'GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleResult',
    'GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleCandidateResponderRuleResult',
    'GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleDetailsResult',
    'GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleDetailsConfigurationResult',
    'GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleDetailsConfigurationValueResult',
    'GetDetectorRecipesFilterResult',
    'GetManagedListsFilterResult',
    'GetManagedListsManagedListCollectionResult',
    'GetManagedListsManagedListCollectionItemResult',
    'GetResponderRecipeEffectiveResponderRuleResult',
    'GetResponderRecipeEffectiveResponderRuleDetailsResult',
    'GetResponderRecipeEffectiveResponderRuleDetailsConfigurationResult',
    'GetResponderRecipeResponderRuleResult',
    'GetResponderRecipeResponderRuleDetailsResult',
    'GetResponderRecipeResponderRuleDetailsConfigurationResult',
    'GetResponderRecipesFilterResult',
    'GetResponderRecipesResponderRecipeCollectionResult',
    'GetResponderRecipesResponderRecipeCollectionItemResult',
    'GetResponderRecipesResponderRecipeCollectionItemEffectiveResponderRuleResult',
    'GetResponderRecipesResponderRecipeCollectionItemEffectiveResponderRuleDetailsResult',
    'GetResponderRecipesResponderRecipeCollectionItemEffectiveResponderRuleDetailsConfigurationResult',
    'GetResponderRecipesResponderRecipeCollectionItemResponderRuleResult',
    'GetResponderRecipesResponderRecipeCollectionItemResponderRuleDetailsResult',
    'GetResponderRecipesResponderRecipeCollectionItemResponderRuleDetailsConfigurationResult',
    'GetTargetTargetDetectorRecipeResult',
    'GetTargetTargetDetectorRecipeDetectorRuleResult',
    'GetTargetTargetDetectorRecipeDetectorRuleDetailsResult',
    'GetTargetTargetDetectorRecipeDetectorRuleDetailsConditionGroupResult',
    'GetTargetTargetDetectorRecipeDetectorRuleDetailsConfigurationResult',
    'GetTargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueResult',
    'GetTargetTargetDetectorRecipeEffectiveDetectorRuleResult',
    'GetTargetTargetDetectorRecipeEffectiveDetectorRuleDetailsResult',
    'GetTargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConditionGroupResult',
    'GetTargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationResult',
    'GetTargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValueResult',
    'GetTargetTargetResponderRecipeResult',
    'GetTargetTargetResponderRecipeEffectiveResponderRuleResult',
    'GetTargetTargetResponderRecipeEffectiveResponderRuleDetailsResult',
    'GetTargetTargetResponderRecipeEffectiveResponderRuleDetailsConfigurationResult',
    'GetTargetTargetResponderRecipeResponderRuleResult',
    'GetTargetTargetResponderRecipeResponderRuleDetailsResult',
    'GetTargetTargetResponderRecipeResponderRuleDetailsConfigurationResult',
    'GetTargetsFilterResult',
    'GetTargetsTargetCollectionResult',
    'GetTargetsTargetCollectionItemResult',
    'GetTargetsTargetCollectionItemTargetDetectorRecipeResult',
    'GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleResult',
    'GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleDetailsResult',
    'GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleDetailsConditionGroupResult',
    'GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleDetailsConfigurationResult',
    'GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleDetailsConfigurationValueResult',
    'GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleResult',
    'GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleDetailsResult',
    'GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleDetailsConditionGroupResult',
    'GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationResult',
    'GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValueResult',
    'GetTargetsTargetCollectionItemTargetResponderRecipeResult',
    'GetTargetsTargetCollectionItemTargetResponderRecipeEffectiveResponderRuleResult',
    'GetTargetsTargetCollectionItemTargetResponderRecipeEffectiveResponderRuleDetailsResult',
    'GetTargetsTargetCollectionItemTargetResponderRecipeEffectiveResponderRuleDetailsConfigurationResult',
    'GetTargetsTargetCollectionItemTargetResponderRecipeResponderRuleResult',
    'GetTargetsTargetCollectionItemTargetResponderRecipeResponderRuleDetailsResult',
    'GetTargetsTargetCollectionItemTargetResponderRecipeResponderRuleDetailsConfigurationResult',
]

@pulumi.output_type
class DataMaskRuleTargetSelected(dict):
    def __init__(__self__, *,
                 kind: str,
                 values: Optional[Sequence[str]] = None):
        """
        :param str kind: (Updatable) Target selection.
        :param Sequence[str] values: (Updatable) Types of Targets
        """
        pulumi.set(__self__, "kind", kind)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def kind(self) -> str:
        """
        (Updatable) Target selection.
        """
        return pulumi.get(self, "kind")

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence[str]]:
        """
        (Updatable) Types of Targets
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class DetectorRecipeDetectorRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "detectorRuleId":
            suggest = "detector_rule_id"
        elif key == "candidateResponderRules":
            suggest = "candidate_responder_rules"
        elif key == "displayName":
            suggest = "display_name"
        elif key == "lifecycleDetails":
            suggest = "lifecycle_details"
        elif key == "managedListTypes":
            suggest = "managed_list_types"
        elif key == "resourceType":
            suggest = "resource_type"
        elif key == "serviceType":
            suggest = "service_type"
        elif key == "timeCreated":
            suggest = "time_created"
        elif key == "timeUpdated":
            suggest = "time_updated"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DetectorRecipeDetectorRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DetectorRecipeDetectorRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DetectorRecipeDetectorRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 details: 'outputs.DetectorRecipeDetectorRuleDetails',
                 detector_rule_id: str,
                 candidate_responder_rules: Optional[Sequence['outputs.DetectorRecipeDetectorRuleCandidateResponderRule']] = None,
                 description: Optional[str] = None,
                 detector: Optional[str] = None,
                 display_name: Optional[str] = None,
                 lifecycle_details: Optional[str] = None,
                 managed_list_types: Optional[Sequence[str]] = None,
                 recommendation: Optional[str] = None,
                 resource_type: Optional[str] = None,
                 service_type: Optional[str] = None,
                 state: Optional[str] = None,
                 time_created: Optional[str] = None,
                 time_updated: Optional[str] = None):
        """
        :param 'DetectorRecipeDetectorRuleDetailsArgs' details: (Updatable) Details of a Detector Rule to be overriden in Detector Recipe
        :param str detector_rule_id: (Updatable) DetectorRecipeRule Identifier
        :param Sequence['DetectorRecipeDetectorRuleCandidateResponderRuleArgs'] candidate_responder_rules: List of CandidateResponderRule related to this rule
        :param str description: (Updatable) DetectorRecipe Description
        :param str detector: detector for the rule
        :param str display_name: (Updatable) DetectorRecipe Display Name
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] managed_list_types: List of cloudguard managed list types related to this rule
        :param str recommendation: Recommendation for DetectorRecipeDetectorRule
        :param str resource_type: resource type of the configuration to which the rule is applied
        :param str service_type: service type of the configuration to which the rule is applied
        :param str state: The current state of the resource.
        :param str time_created: The date and time the detector recipe was created. Format defined by RFC3339.
        :param str time_updated: The date and time the detector recipe was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "detector_rule_id", detector_rule_id)
        if candidate_responder_rules is not None:
            pulumi.set(__self__, "candidate_responder_rules", candidate_responder_rules)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if detector is not None:
            pulumi.set(__self__, "detector", detector)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if lifecycle_details is not None:
            pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        if managed_list_types is not None:
            pulumi.set(__self__, "managed_list_types", managed_list_types)
        if recommendation is not None:
            pulumi.set(__self__, "recommendation", recommendation)
        if resource_type is not None:
            pulumi.set(__self__, "resource_type", resource_type)
        if service_type is not None:
            pulumi.set(__self__, "service_type", service_type)
        if state is not None:
            pulumi.set(__self__, "state", state)
        if time_created is not None:
            pulumi.set(__self__, "time_created", time_created)
        if time_updated is not None:
            pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter
    def details(self) -> 'outputs.DetectorRecipeDetectorRuleDetails':
        """
        (Updatable) Details of a Detector Rule to be overriden in Detector Recipe
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter(name="detectorRuleId")
    def detector_rule_id(self) -> str:
        """
        (Updatable) DetectorRecipeRule Identifier
        """
        return pulumi.get(self, "detector_rule_id")

    @property
    @pulumi.getter(name="candidateResponderRules")
    def candidate_responder_rules(self) -> Optional[Sequence['outputs.DetectorRecipeDetectorRuleCandidateResponderRule']]:
        """
        List of CandidateResponderRule related to this rule
        """
        return pulumi.get(self, "candidate_responder_rules")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        (Updatable) DetectorRecipe Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def detector(self) -> Optional[str]:
        """
        detector for the rule
        """
        return pulumi.get(self, "detector")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[str]:
        """
        (Updatable) DetectorRecipe Display Name
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> Optional[str]:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter(name="managedListTypes")
    def managed_list_types(self) -> Optional[Sequence[str]]:
        """
        List of cloudguard managed list types related to this rule
        """
        return pulumi.get(self, "managed_list_types")

    @property
    @pulumi.getter
    def recommendation(self) -> Optional[str]:
        """
        Recommendation for DetectorRecipeDetectorRule
        """
        return pulumi.get(self, "recommendation")

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> Optional[str]:
        """
        resource type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "resource_type")

    @property
    @pulumi.getter(name="serviceType")
    def service_type(self) -> Optional[str]:
        """
        service type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "service_type")

    @property
    @pulumi.getter
    def state(self) -> Optional[str]:
        """
        The current state of the resource.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> Optional[str]:
        """
        The date and time the detector recipe was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> Optional[str]:
        """
        The date and time the detector recipe was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class DetectorRecipeDetectorRuleCandidateResponderRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "displayName":
            suggest = "display_name"
        elif key == "isPreferred":
            suggest = "is_preferred"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DetectorRecipeDetectorRuleCandidateResponderRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DetectorRecipeDetectorRuleCandidateResponderRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DetectorRecipeDetectorRuleCandidateResponderRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 display_name: Optional[str] = None,
                 id: Optional[str] = None,
                 is_preferred: Optional[bool] = None):
        """
        :param str display_name: (Updatable) DetectorRecipe Display Name
        :param str id: Ocid for detector recipe
        :param bool is_preferred: Preferred state
        """
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if is_preferred is not None:
            pulumi.set(__self__, "is_preferred", is_preferred)

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[str]:
        """
        (Updatable) DetectorRecipe Display Name
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Ocid for detector recipe
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="isPreferred")
    def is_preferred(self) -> Optional[bool]:
        """
        Preferred state
        """
        return pulumi.get(self, "is_preferred")


@pulumi.output_type
class DetectorRecipeDetectorRuleDetails(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isEnabled":
            suggest = "is_enabled"
        elif key == "riskLevel":
            suggest = "risk_level"
        elif key == "isConfigurationAllowed":
            suggest = "is_configuration_allowed"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DetectorRecipeDetectorRuleDetails. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DetectorRecipeDetectorRuleDetails.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DetectorRecipeDetectorRuleDetails.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 is_enabled: bool,
                 risk_level: str,
                 condition: Optional[str] = None,
                 configurations: Optional[Sequence['outputs.DetectorRecipeDetectorRuleDetailsConfiguration']] = None,
                 is_configuration_allowed: Optional[bool] = None,
                 labels: Optional[Sequence[str]] = None):
        """
        :param bool is_enabled: (Updatable) Enables the control
        :param str risk_level: (Updatable) The Risk Level
        :param str condition: (Updatable)
        :param Sequence['DetectorRecipeDetectorRuleDetailsConfigurationArgs'] configurations: (Updatable) Configuration details
        :param bool is_configuration_allowed: configuration allowed or not
        :param Sequence[str] labels: (Updatable) user defined labels for a detector rule
        """
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "risk_level", risk_level)
        if condition is not None:
            pulumi.set(__self__, "condition", condition)
        if configurations is not None:
            pulumi.set(__self__, "configurations", configurations)
        if is_configuration_allowed is not None:
            pulumi.set(__self__, "is_configuration_allowed", is_configuration_allowed)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        """
        (Updatable) Enables the control
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter(name="riskLevel")
    def risk_level(self) -> str:
        """
        (Updatable) The Risk Level
        """
        return pulumi.get(self, "risk_level")

    @property
    @pulumi.getter
    def condition(self) -> Optional[str]:
        """
        (Updatable)
        """
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter
    def configurations(self) -> Optional[Sequence['outputs.DetectorRecipeDetectorRuleDetailsConfiguration']]:
        """
        (Updatable) Configuration details
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isConfigurationAllowed")
    def is_configuration_allowed(self) -> Optional[bool]:
        """
        configuration allowed or not
        """
        return pulumi.get(self, "is_configuration_allowed")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Sequence[str]]:
        """
        (Updatable) user defined labels for a detector rule
        """
        return pulumi.get(self, "labels")


@pulumi.output_type
class DetectorRecipeDetectorRuleDetailsConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configKey":
            suggest = "config_key"
        elif key == "dataType":
            suggest = "data_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DetectorRecipeDetectorRuleDetailsConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DetectorRecipeDetectorRuleDetailsConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DetectorRecipeDetectorRuleDetailsConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 config_key: str,
                 name: str,
                 data_type: Optional[str] = None,
                 value: Optional[str] = None,
                 values: Optional[Sequence['outputs.DetectorRecipeDetectorRuleDetailsConfigurationValue']] = None):
        """
        :param str config_key: (Updatable) Unique name of the configuration
        :param str name: (Updatable) configuration name
        :param str data_type: (Updatable) configuration data type
        :param str value: (Updatable) configuration value
        :param Sequence['DetectorRecipeDetectorRuleDetailsConfigurationValueArgs'] values: (Updatable) List of configuration values
        """
        pulumi.set(__self__, "config_key", config_key)
        pulumi.set(__self__, "name", name)
        if data_type is not None:
            pulumi.set(__self__, "data_type", data_type)
        if value is not None:
            pulumi.set(__self__, "value", value)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> str:
        """
        (Updatable) Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        (Updatable) configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="dataType")
    def data_type(self) -> Optional[str]:
        """
        (Updatable) configuration data type
        """
        return pulumi.get(self, "data_type")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        (Updatable) configuration value
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence['outputs.DetectorRecipeDetectorRuleDetailsConfigurationValue']]:
        """
        (Updatable) List of configuration values
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class DetectorRecipeDetectorRuleDetailsConfigurationValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "listType":
            suggest = "list_type"
        elif key == "managedListType":
            suggest = "managed_list_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DetectorRecipeDetectorRuleDetailsConfigurationValue. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DetectorRecipeDetectorRuleDetailsConfigurationValue.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DetectorRecipeDetectorRuleDetailsConfigurationValue.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 list_type: str,
                 managed_list_type: str,
                 value: str):
        """
        :param str list_type: (Updatable) configuration list item type, either CUSTOM or MANAGED
        :param str managed_list_type: (Updatable) type of the managed list
        :param str value: (Updatable) configuration value
        """
        pulumi.set(__self__, "list_type", list_type)
        pulumi.set(__self__, "managed_list_type", managed_list_type)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="listType")
    def list_type(self) -> str:
        """
        (Updatable) configuration list item type, either CUSTOM or MANAGED
        """
        return pulumi.get(self, "list_type")

    @property
    @pulumi.getter(name="managedListType")
    def managed_list_type(self) -> str:
        """
        (Updatable) type of the managed list
        """
        return pulumi.get(self, "managed_list_type")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        (Updatable) configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class DetectorRecipeEffectiveDetectorRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "candidateResponderRules":
            suggest = "candidate_responder_rules"
        elif key == "detectorRuleId":
            suggest = "detector_rule_id"
        elif key == "displayName":
            suggest = "display_name"
        elif key == "lifecycleDetails":
            suggest = "lifecycle_details"
        elif key == "managedListTypes":
            suggest = "managed_list_types"
        elif key == "resourceType":
            suggest = "resource_type"
        elif key == "serviceType":
            suggest = "service_type"
        elif key == "timeCreated":
            suggest = "time_created"
        elif key == "timeUpdated":
            suggest = "time_updated"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DetectorRecipeEffectiveDetectorRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DetectorRecipeEffectiveDetectorRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DetectorRecipeEffectiveDetectorRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 candidate_responder_rules: Optional[Sequence['outputs.DetectorRecipeEffectiveDetectorRuleCandidateResponderRule']] = None,
                 description: Optional[str] = None,
                 details: Optional['outputs.DetectorRecipeEffectiveDetectorRuleDetails'] = None,
                 detector: Optional[str] = None,
                 detector_rule_id: Optional[str] = None,
                 display_name: Optional[str] = None,
                 lifecycle_details: Optional[str] = None,
                 managed_list_types: Optional[Sequence[str]] = None,
                 recommendation: Optional[str] = None,
                 resource_type: Optional[str] = None,
                 service_type: Optional[str] = None,
                 state: Optional[str] = None,
                 time_created: Optional[str] = None,
                 time_updated: Optional[str] = None):
        """
        :param Sequence['DetectorRecipeEffectiveDetectorRuleCandidateResponderRuleArgs'] candidate_responder_rules: List of CandidateResponderRule related to this rule
        :param str description: (Updatable) DetectorRecipe Description
        :param 'DetectorRecipeEffectiveDetectorRuleDetailsArgs' details: (Updatable) Details of a Detector Rule to be overriden in Detector Recipe
        :param str detector: detector for the rule
        :param str detector_rule_id: (Updatable) DetectorRecipeRule Identifier
        :param str display_name: (Updatable) DetectorRecipe Display Name
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] managed_list_types: List of cloudguard managed list types related to this rule
        :param str recommendation: Recommendation for DetectorRecipeDetectorRule
        :param str resource_type: resource type of the configuration to which the rule is applied
        :param str service_type: service type of the configuration to which the rule is applied
        :param str state: The current state of the resource.
        :param str time_created: The date and time the detector recipe was created. Format defined by RFC3339.
        :param str time_updated: The date and time the detector recipe was updated. Format defined by RFC3339.
        """
        if candidate_responder_rules is not None:
            pulumi.set(__self__, "candidate_responder_rules", candidate_responder_rules)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if details is not None:
            pulumi.set(__self__, "details", details)
        if detector is not None:
            pulumi.set(__self__, "detector", detector)
        if detector_rule_id is not None:
            pulumi.set(__self__, "detector_rule_id", detector_rule_id)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if lifecycle_details is not None:
            pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        if managed_list_types is not None:
            pulumi.set(__self__, "managed_list_types", managed_list_types)
        if recommendation is not None:
            pulumi.set(__self__, "recommendation", recommendation)
        if resource_type is not None:
            pulumi.set(__self__, "resource_type", resource_type)
        if service_type is not None:
            pulumi.set(__self__, "service_type", service_type)
        if state is not None:
            pulumi.set(__self__, "state", state)
        if time_created is not None:
            pulumi.set(__self__, "time_created", time_created)
        if time_updated is not None:
            pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter(name="candidateResponderRules")
    def candidate_responder_rules(self) -> Optional[Sequence['outputs.DetectorRecipeEffectiveDetectorRuleCandidateResponderRule']]:
        """
        List of CandidateResponderRule related to this rule
        """
        return pulumi.get(self, "candidate_responder_rules")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        (Updatable) DetectorRecipe Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def details(self) -> Optional['outputs.DetectorRecipeEffectiveDetectorRuleDetails']:
        """
        (Updatable) Details of a Detector Rule to be overriden in Detector Recipe
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter
    def detector(self) -> Optional[str]:
        """
        detector for the rule
        """
        return pulumi.get(self, "detector")

    @property
    @pulumi.getter(name="detectorRuleId")
    def detector_rule_id(self) -> Optional[str]:
        """
        (Updatable) DetectorRecipeRule Identifier
        """
        return pulumi.get(self, "detector_rule_id")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[str]:
        """
        (Updatable) DetectorRecipe Display Name
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> Optional[str]:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter(name="managedListTypes")
    def managed_list_types(self) -> Optional[Sequence[str]]:
        """
        List of cloudguard managed list types related to this rule
        """
        return pulumi.get(self, "managed_list_types")

    @property
    @pulumi.getter
    def recommendation(self) -> Optional[str]:
        """
        Recommendation for DetectorRecipeDetectorRule
        """
        return pulumi.get(self, "recommendation")

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> Optional[str]:
        """
        resource type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "resource_type")

    @property
    @pulumi.getter(name="serviceType")
    def service_type(self) -> Optional[str]:
        """
        service type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "service_type")

    @property
    @pulumi.getter
    def state(self) -> Optional[str]:
        """
        The current state of the resource.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> Optional[str]:
        """
        The date and time the detector recipe was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> Optional[str]:
        """
        The date and time the detector recipe was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class DetectorRecipeEffectiveDetectorRuleCandidateResponderRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "displayName":
            suggest = "display_name"
        elif key == "isPreferred":
            suggest = "is_preferred"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DetectorRecipeEffectiveDetectorRuleCandidateResponderRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DetectorRecipeEffectiveDetectorRuleCandidateResponderRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DetectorRecipeEffectiveDetectorRuleCandidateResponderRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 display_name: Optional[str] = None,
                 id: Optional[str] = None,
                 is_preferred: Optional[bool] = None):
        """
        :param str display_name: (Updatable) DetectorRecipe Display Name
        :param str id: Ocid for detector recipe
        :param bool is_preferred: Preferred state
        """
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if is_preferred is not None:
            pulumi.set(__self__, "is_preferred", is_preferred)

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[str]:
        """
        (Updatable) DetectorRecipe Display Name
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Ocid for detector recipe
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="isPreferred")
    def is_preferred(self) -> Optional[bool]:
        """
        Preferred state
        """
        return pulumi.get(self, "is_preferred")


@pulumi.output_type
class DetectorRecipeEffectiveDetectorRuleDetails(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isConfigurationAllowed":
            suggest = "is_configuration_allowed"
        elif key == "isEnabled":
            suggest = "is_enabled"
        elif key == "riskLevel":
            suggest = "risk_level"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DetectorRecipeEffectiveDetectorRuleDetails. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DetectorRecipeEffectiveDetectorRuleDetails.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DetectorRecipeEffectiveDetectorRuleDetails.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition: Optional[str] = None,
                 configurations: Optional[Sequence['outputs.DetectorRecipeEffectiveDetectorRuleDetailsConfiguration']] = None,
                 is_configuration_allowed: Optional[bool] = None,
                 is_enabled: Optional[bool] = None,
                 labels: Optional[Sequence[str]] = None,
                 risk_level: Optional[str] = None):
        """
        :param str condition: (Updatable)
        :param Sequence['DetectorRecipeEffectiveDetectorRuleDetailsConfigurationArgs'] configurations: (Updatable) Configuration details
        :param bool is_configuration_allowed: configuration allowed or not
        :param bool is_enabled: (Updatable) Enables the control
        :param Sequence[str] labels: (Updatable) user defined labels for a detector rule
        :param str risk_level: (Updatable) The Risk Level
        """
        if condition is not None:
            pulumi.set(__self__, "condition", condition)
        if configurations is not None:
            pulumi.set(__self__, "configurations", configurations)
        if is_configuration_allowed is not None:
            pulumi.set(__self__, "is_configuration_allowed", is_configuration_allowed)
        if is_enabled is not None:
            pulumi.set(__self__, "is_enabled", is_enabled)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if risk_level is not None:
            pulumi.set(__self__, "risk_level", risk_level)

    @property
    @pulumi.getter
    def condition(self) -> Optional[str]:
        """
        (Updatable)
        """
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter
    def configurations(self) -> Optional[Sequence['outputs.DetectorRecipeEffectiveDetectorRuleDetailsConfiguration']]:
        """
        (Updatable) Configuration details
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isConfigurationAllowed")
    def is_configuration_allowed(self) -> Optional[bool]:
        """
        configuration allowed or not
        """
        return pulumi.get(self, "is_configuration_allowed")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> Optional[bool]:
        """
        (Updatable) Enables the control
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Sequence[str]]:
        """
        (Updatable) user defined labels for a detector rule
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="riskLevel")
    def risk_level(self) -> Optional[str]:
        """
        (Updatable) The Risk Level
        """
        return pulumi.get(self, "risk_level")


@pulumi.output_type
class DetectorRecipeEffectiveDetectorRuleDetailsConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configKey":
            suggest = "config_key"
        elif key == "dataType":
            suggest = "data_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DetectorRecipeEffectiveDetectorRuleDetailsConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DetectorRecipeEffectiveDetectorRuleDetailsConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DetectorRecipeEffectiveDetectorRuleDetailsConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 config_key: Optional[str] = None,
                 data_type: Optional[str] = None,
                 name: Optional[str] = None,
                 value: Optional[str] = None,
                 values: Optional[Sequence['outputs.DetectorRecipeEffectiveDetectorRuleDetailsConfigurationValue']] = None):
        """
        :param str config_key: (Updatable) Unique name of the configuration
        :param str data_type: (Updatable) configuration data type
        :param str name: (Updatable) configuration name
        :param str value: (Updatable) configuration value
        :param Sequence['DetectorRecipeEffectiveDetectorRuleDetailsConfigurationValueArgs'] values: (Updatable) List of configuration values
        """
        if config_key is not None:
            pulumi.set(__self__, "config_key", config_key)
        if data_type is not None:
            pulumi.set(__self__, "data_type", data_type)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> Optional[str]:
        """
        (Updatable) Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter(name="dataType")
    def data_type(self) -> Optional[str]:
        """
        (Updatable) configuration data type
        """
        return pulumi.get(self, "data_type")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        (Updatable) configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        (Updatable) configuration value
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence['outputs.DetectorRecipeEffectiveDetectorRuleDetailsConfigurationValue']]:
        """
        (Updatable) List of configuration values
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class DetectorRecipeEffectiveDetectorRuleDetailsConfigurationValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "listType":
            suggest = "list_type"
        elif key == "managedListType":
            suggest = "managed_list_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DetectorRecipeEffectiveDetectorRuleDetailsConfigurationValue. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DetectorRecipeEffectiveDetectorRuleDetailsConfigurationValue.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DetectorRecipeEffectiveDetectorRuleDetailsConfigurationValue.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 list_type: Optional[str] = None,
                 managed_list_type: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str list_type: (Updatable) configuration list item type, either CUSTOM or MANAGED
        :param str managed_list_type: (Updatable) type of the managed list
        :param str value: (Updatable) configuration value
        """
        if list_type is not None:
            pulumi.set(__self__, "list_type", list_type)
        if managed_list_type is not None:
            pulumi.set(__self__, "managed_list_type", managed_list_type)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="listType")
    def list_type(self) -> Optional[str]:
        """
        (Updatable) configuration list item type, either CUSTOM or MANAGED
        """
        return pulumi.get(self, "list_type")

    @property
    @pulumi.getter(name="managedListType")
    def managed_list_type(self) -> Optional[str]:
        """
        (Updatable) type of the managed list
        """
        return pulumi.get(self, "managed_list_type")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        (Updatable) configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class ResponderRecipeEffectiveResponderRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "compartmentId":
            suggest = "compartment_id"
        elif key == "displayName":
            suggest = "display_name"
        elif key == "lifecycleDetails":
            suggest = "lifecycle_details"
        elif key == "responderRuleId":
            suggest = "responder_rule_id"
        elif key == "supportedModes":
            suggest = "supported_modes"
        elif key == "timeCreated":
            suggest = "time_created"
        elif key == "timeUpdated":
            suggest = "time_updated"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ResponderRecipeEffectiveResponderRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ResponderRecipeEffectiveResponderRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ResponderRecipeEffectiveResponderRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 compartment_id: Optional[str] = None,
                 description: Optional[str] = None,
                 details: Optional['outputs.ResponderRecipeEffectiveResponderRuleDetails'] = None,
                 display_name: Optional[str] = None,
                 lifecycle_details: Optional[str] = None,
                 policies: Optional[Sequence[str]] = None,
                 responder_rule_id: Optional[str] = None,
                 state: Optional[str] = None,
                 supported_modes: Optional[Sequence[str]] = None,
                 time_created: Optional[str] = None,
                 time_updated: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param str compartment_id: (Updatable) Compartment Identifier
        :param str description: (Updatable) ResponderRecipe Description
        :param 'ResponderRecipeEffectiveResponderRuleDetailsArgs' details: (Updatable) Details of UpdateResponderRuleDetails.
        :param str display_name: (Updatable) ResponderRecipe Display Name
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] policies: List of Policy
        :param str responder_rule_id: (Updatable) ResponderRecipeRule Identifier
        :param str state: The current state of the Example.
        :param Sequence[str] supported_modes: Supported Execution Modes
        :param str time_created: The date and time the responder recipe was created. Format defined by RFC3339.
        :param str time_updated: The date and time the responder recipe was updated. Format defined by RFC3339.
        :param str type: Type of Responder
        """
        if compartment_id is not None:
            pulumi.set(__self__, "compartment_id", compartment_id)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if details is not None:
            pulumi.set(__self__, "details", details)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if lifecycle_details is not None:
            pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        if policies is not None:
            pulumi.set(__self__, "policies", policies)
        if responder_rule_id is not None:
            pulumi.set(__self__, "responder_rule_id", responder_rule_id)
        if state is not None:
            pulumi.set(__self__, "state", state)
        if supported_modes is not None:
            pulumi.set(__self__, "supported_modes", supported_modes)
        if time_created is not None:
            pulumi.set(__self__, "time_created", time_created)
        if time_updated is not None:
            pulumi.set(__self__, "time_updated", time_updated)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> Optional[str]:
        """
        (Updatable) Compartment Identifier
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        (Updatable) ResponderRecipe Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def details(self) -> Optional['outputs.ResponderRecipeEffectiveResponderRuleDetails']:
        """
        (Updatable) Details of UpdateResponderRuleDetails.
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[str]:
        """
        (Updatable) ResponderRecipe Display Name
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> Optional[str]:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter
    def policies(self) -> Optional[Sequence[str]]:
        """
        List of Policy
        """
        return pulumi.get(self, "policies")

    @property
    @pulumi.getter(name="responderRuleId")
    def responder_rule_id(self) -> Optional[str]:
        """
        (Updatable) ResponderRecipeRule Identifier
        """
        return pulumi.get(self, "responder_rule_id")

    @property
    @pulumi.getter
    def state(self) -> Optional[str]:
        """
        The current state of the Example.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="supportedModes")
    def supported_modes(self) -> Optional[Sequence[str]]:
        """
        Supported Execution Modes
        """
        return pulumi.get(self, "supported_modes")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> Optional[str]:
        """
        The date and time the responder recipe was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> Optional[str]:
        """
        The date and time the responder recipe was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        Type of Responder
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class ResponderRecipeEffectiveResponderRuleDetails(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isEnabled":
            suggest = "is_enabled"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ResponderRecipeEffectiveResponderRuleDetails. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ResponderRecipeEffectiveResponderRuleDetails.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ResponderRecipeEffectiveResponderRuleDetails.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition: Optional[str] = None,
                 configurations: Optional[Sequence['outputs.ResponderRecipeEffectiveResponderRuleDetailsConfiguration']] = None,
                 is_enabled: Optional[bool] = None,
                 mode: Optional[str] = None):
        """
        :param Sequence['ResponderRecipeEffectiveResponderRuleDetailsConfigurationArgs'] configurations: ResponderRule configurations
        :param bool is_enabled: (Updatable) Identifies state for ResponderRule
        :param str mode: Execution Mode for ResponderRule
        """
        if condition is not None:
            pulumi.set(__self__, "condition", condition)
        if configurations is not None:
            pulumi.set(__self__, "configurations", configurations)
        if is_enabled is not None:
            pulumi.set(__self__, "is_enabled", is_enabled)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def condition(self) -> Optional[str]:
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter
    def configurations(self) -> Optional[Sequence['outputs.ResponderRecipeEffectiveResponderRuleDetailsConfiguration']]:
        """
        ResponderRule configurations
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> Optional[bool]:
        """
        (Updatable) Identifies state for ResponderRule
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def mode(self) -> Optional[str]:
        """
        Execution Mode for ResponderRule
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class ResponderRecipeEffectiveResponderRuleDetailsConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configKey":
            suggest = "config_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ResponderRecipeEffectiveResponderRuleDetailsConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ResponderRecipeEffectiveResponderRuleDetailsConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ResponderRecipeEffectiveResponderRuleDetailsConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 config_key: Optional[str] = None,
                 name: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str config_key: Unique name of the configuration
        :param str name: configuration name
        :param str value: configuration value
        """
        if config_key is not None:
            pulumi.set(__self__, "config_key", config_key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> Optional[str]:
        """
        Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class ResponderRecipeResponderRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "responderRuleId":
            suggest = "responder_rule_id"
        elif key == "compartmentId":
            suggest = "compartment_id"
        elif key == "displayName":
            suggest = "display_name"
        elif key == "lifecycleDetails":
            suggest = "lifecycle_details"
        elif key == "supportedModes":
            suggest = "supported_modes"
        elif key == "timeCreated":
            suggest = "time_created"
        elif key == "timeUpdated":
            suggest = "time_updated"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ResponderRecipeResponderRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ResponderRecipeResponderRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ResponderRecipeResponderRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 details: 'outputs.ResponderRecipeResponderRuleDetails',
                 responder_rule_id: str,
                 compartment_id: Optional[str] = None,
                 description: Optional[str] = None,
                 display_name: Optional[str] = None,
                 lifecycle_details: Optional[str] = None,
                 policies: Optional[Sequence[str]] = None,
                 state: Optional[str] = None,
                 supported_modes: Optional[Sequence[str]] = None,
                 time_created: Optional[str] = None,
                 time_updated: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param 'ResponderRecipeResponderRuleDetailsArgs' details: (Updatable) Details of UpdateResponderRuleDetails.
        :param str responder_rule_id: (Updatable) ResponderRecipeRule Identifier
        :param str compartment_id: (Updatable) Compartment Identifier
        :param str description: (Updatable) ResponderRecipe Description
        :param str display_name: (Updatable) ResponderRecipe Display Name
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] policies: List of Policy
        :param str state: The current state of the Example.
        :param Sequence[str] supported_modes: Supported Execution Modes
        :param str time_created: The date and time the responder recipe was created. Format defined by RFC3339.
        :param str time_updated: The date and time the responder recipe was updated. Format defined by RFC3339.
        :param str type: Type of Responder
        """
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "responder_rule_id", responder_rule_id)
        if compartment_id is not None:
            pulumi.set(__self__, "compartment_id", compartment_id)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if lifecycle_details is not None:
            pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        if policies is not None:
            pulumi.set(__self__, "policies", policies)
        if state is not None:
            pulumi.set(__self__, "state", state)
        if supported_modes is not None:
            pulumi.set(__self__, "supported_modes", supported_modes)
        if time_created is not None:
            pulumi.set(__self__, "time_created", time_created)
        if time_updated is not None:
            pulumi.set(__self__, "time_updated", time_updated)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def details(self) -> 'outputs.ResponderRecipeResponderRuleDetails':
        """
        (Updatable) Details of UpdateResponderRuleDetails.
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter(name="responderRuleId")
    def responder_rule_id(self) -> str:
        """
        (Updatable) ResponderRecipeRule Identifier
        """
        return pulumi.get(self, "responder_rule_id")

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> Optional[str]:
        """
        (Updatable) Compartment Identifier
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        (Updatable) ResponderRecipe Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[str]:
        """
        (Updatable) ResponderRecipe Display Name
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> Optional[str]:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter
    def policies(self) -> Optional[Sequence[str]]:
        """
        List of Policy
        """
        return pulumi.get(self, "policies")

    @property
    @pulumi.getter
    def state(self) -> Optional[str]:
        """
        The current state of the Example.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="supportedModes")
    def supported_modes(self) -> Optional[Sequence[str]]:
        """
        Supported Execution Modes
        """
        return pulumi.get(self, "supported_modes")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> Optional[str]:
        """
        The date and time the responder recipe was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> Optional[str]:
        """
        The date and time the responder recipe was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        Type of Responder
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class ResponderRecipeResponderRuleDetails(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isEnabled":
            suggest = "is_enabled"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ResponderRecipeResponderRuleDetails. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ResponderRecipeResponderRuleDetails.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ResponderRecipeResponderRuleDetails.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 is_enabled: bool,
                 condition: Optional[str] = None,
                 configurations: Optional[Sequence['outputs.ResponderRecipeResponderRuleDetailsConfiguration']] = None,
                 mode: Optional[str] = None):
        """
        :param bool is_enabled: (Updatable) Identifies state for ResponderRule
        :param Sequence['ResponderRecipeResponderRuleDetailsConfigurationArgs'] configurations: ResponderRule configurations
        :param str mode: Execution Mode for ResponderRule
        """
        pulumi.set(__self__, "is_enabled", is_enabled)
        if condition is not None:
            pulumi.set(__self__, "condition", condition)
        if configurations is not None:
            pulumi.set(__self__, "configurations", configurations)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        """
        (Updatable) Identifies state for ResponderRule
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def condition(self) -> Optional[str]:
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter
    def configurations(self) -> Optional[Sequence['outputs.ResponderRecipeResponderRuleDetailsConfiguration']]:
        """
        ResponderRule configurations
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter
    def mode(self) -> Optional[str]:
        """
        Execution Mode for ResponderRule
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class ResponderRecipeResponderRuleDetailsConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configKey":
            suggest = "config_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ResponderRecipeResponderRuleDetailsConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ResponderRecipeResponderRuleDetailsConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ResponderRecipeResponderRuleDetailsConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 config_key: Optional[str] = None,
                 name: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str config_key: Unique name of the configuration
        :param str name: configuration name
        :param str value: configuration value
        """
        if config_key is not None:
            pulumi.set(__self__, "config_key", config_key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> Optional[str]:
        """
        Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class TargetTargetDetectorRecipe(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "detectorRecipeId":
            suggest = "detector_recipe_id"
        elif key == "compartmentId":
            suggest = "compartment_id"
        elif key == "detectorRules":
            suggest = "detector_rules"
        elif key == "displayName":
            suggest = "display_name"
        elif key == "effectiveDetectorRules":
            suggest = "effective_detector_rules"
        elif key == "timeCreated":
            suggest = "time_created"
        elif key == "timeUpdated":
            suggest = "time_updated"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TargetTargetDetectorRecipe. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TargetTargetDetectorRecipe.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TargetTargetDetectorRecipe.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 detector_recipe_id: str,
                 compartment_id: Optional[str] = None,
                 description: Optional[str] = None,
                 detector: Optional[str] = None,
                 detector_rules: Optional[Sequence['outputs.TargetTargetDetectorRecipeDetectorRule']] = None,
                 display_name: Optional[str] = None,
                 effective_detector_rules: Optional[Sequence['outputs.TargetTargetDetectorRecipeEffectiveDetectorRule']] = None,
                 id: Optional[str] = None,
                 owner: Optional[str] = None,
                 state: Optional[str] = None,
                 time_created: Optional[str] = None,
                 time_updated: Optional[str] = None):
        """
        :param str detector_recipe_id: Identifier for DetectorRecipe.
        :param str compartment_id: (Updatable) compartment associated with condition
        :param str description: The target description.
        :param str detector: detector for the rule
        :param Sequence['TargetTargetDetectorRecipeDetectorRuleArgs'] detector_rules: (Updatable) Overrides to be applied to Detector Rule associated with the target
        :param str display_name: (Updatable) DetectorTemplate Identifier
        :param Sequence['TargetTargetDetectorRecipeEffectiveDetectorRuleArgs'] effective_detector_rules: List of effective detector rules for the detector type for recipe after applying defaults
        :param str id: Unique identifier of TargetResponderRecipe that is immutable on creation
        :param str owner: Owner of ResponderRecipe
        :param str state: (Updatable) The current state of the DetectorRule.
        :param str time_created: The date and time the target was created. Format defined by RFC3339.
        :param str time_updated: The date and time the target was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "detector_recipe_id", detector_recipe_id)
        if compartment_id is not None:
            pulumi.set(__self__, "compartment_id", compartment_id)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if detector is not None:
            pulumi.set(__self__, "detector", detector)
        if detector_rules is not None:
            pulumi.set(__self__, "detector_rules", detector_rules)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if effective_detector_rules is not None:
            pulumi.set(__self__, "effective_detector_rules", effective_detector_rules)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if owner is not None:
            pulumi.set(__self__, "owner", owner)
        if state is not None:
            pulumi.set(__self__, "state", state)
        if time_created is not None:
            pulumi.set(__self__, "time_created", time_created)
        if time_updated is not None:
            pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter(name="detectorRecipeId")
    def detector_recipe_id(self) -> str:
        """
        Identifier for DetectorRecipe.
        """
        return pulumi.get(self, "detector_recipe_id")

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> Optional[str]:
        """
        (Updatable) compartment associated with condition
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        The target description.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def detector(self) -> Optional[str]:
        """
        detector for the rule
        """
        return pulumi.get(self, "detector")

    @property
    @pulumi.getter(name="detectorRules")
    def detector_rules(self) -> Optional[Sequence['outputs.TargetTargetDetectorRecipeDetectorRule']]:
        """
        (Updatable) Overrides to be applied to Detector Rule associated with the target
        """
        return pulumi.get(self, "detector_rules")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[str]:
        """
        (Updatable) DetectorTemplate Identifier
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="effectiveDetectorRules")
    def effective_detector_rules(self) -> Optional[Sequence['outputs.TargetTargetDetectorRecipeEffectiveDetectorRule']]:
        """
        List of effective detector rules for the detector type for recipe after applying defaults
        """
        return pulumi.get(self, "effective_detector_rules")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Unique identifier of TargetResponderRecipe that is immutable on creation
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def owner(self) -> Optional[str]:
        """
        Owner of ResponderRecipe
        """
        return pulumi.get(self, "owner")

    @property
    @pulumi.getter
    def state(self) -> Optional[str]:
        """
        (Updatable) The current state of the DetectorRule.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> Optional[str]:
        """
        The date and time the target was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> Optional[str]:
        """
        The date and time the target was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class TargetTargetDetectorRecipeDetectorRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "detectorRuleId":
            suggest = "detector_rule_id"
        elif key == "displayName":
            suggest = "display_name"
        elif key == "lifecycleDetails":
            suggest = "lifecycle_details"
        elif key == "managedListTypes":
            suggest = "managed_list_types"
        elif key == "resourceType":
            suggest = "resource_type"
        elif key == "serviceType":
            suggest = "service_type"
        elif key == "timeCreated":
            suggest = "time_created"
        elif key == "timeUpdated":
            suggest = "time_updated"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TargetTargetDetectorRecipeDetectorRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TargetTargetDetectorRecipeDetectorRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TargetTargetDetectorRecipeDetectorRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 details: 'outputs.TargetTargetDetectorRecipeDetectorRuleDetails',
                 detector_rule_id: str,
                 description: Optional[str] = None,
                 detector: Optional[str] = None,
                 display_name: Optional[str] = None,
                 lifecycle_details: Optional[str] = None,
                 managed_list_types: Optional[Sequence[str]] = None,
                 recommendation: Optional[str] = None,
                 resource_type: Optional[str] = None,
                 service_type: Optional[str] = None,
                 state: Optional[str] = None,
                 time_created: Optional[str] = None,
                 time_updated: Optional[str] = None):
        """
        :param 'TargetTargetDetectorRecipeDetectorRuleDetailsArgs' details: (Updatable) Details of ResponderRule.
        :param str detector_rule_id: (Updatable) Identifier for DetectorRule.
        :param str description: The target description.
        :param str detector: detector for the rule
        :param str display_name: (Updatable) DetectorTemplate Identifier
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] managed_list_types: List of cloudguard managed list types related to this rule
        :param str recommendation: Recommendation for TargetDetectorRecipeDetectorRule
        :param str resource_type: resource type of the configuration to which the rule is applied
        :param str service_type: service type of the configuration to which the rule is applied
        :param str state: (Updatable) The current state of the DetectorRule.
        :param str time_created: The date and time the target was created. Format defined by RFC3339.
        :param str time_updated: The date and time the target was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "detector_rule_id", detector_rule_id)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if detector is not None:
            pulumi.set(__self__, "detector", detector)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if lifecycle_details is not None:
            pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        if managed_list_types is not None:
            pulumi.set(__self__, "managed_list_types", managed_list_types)
        if recommendation is not None:
            pulumi.set(__self__, "recommendation", recommendation)
        if resource_type is not None:
            pulumi.set(__self__, "resource_type", resource_type)
        if service_type is not None:
            pulumi.set(__self__, "service_type", service_type)
        if state is not None:
            pulumi.set(__self__, "state", state)
        if time_created is not None:
            pulumi.set(__self__, "time_created", time_created)
        if time_updated is not None:
            pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter
    def details(self) -> 'outputs.TargetTargetDetectorRecipeDetectorRuleDetails':
        """
        (Updatable) Details of ResponderRule.
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter(name="detectorRuleId")
    def detector_rule_id(self) -> str:
        """
        (Updatable) Identifier for DetectorRule.
        """
        return pulumi.get(self, "detector_rule_id")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        The target description.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def detector(self) -> Optional[str]:
        """
        detector for the rule
        """
        return pulumi.get(self, "detector")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[str]:
        """
        (Updatable) DetectorTemplate Identifier
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> Optional[str]:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter(name="managedListTypes")
    def managed_list_types(self) -> Optional[Sequence[str]]:
        """
        List of cloudguard managed list types related to this rule
        """
        return pulumi.get(self, "managed_list_types")

    @property
    @pulumi.getter
    def recommendation(self) -> Optional[str]:
        """
        Recommendation for TargetDetectorRecipeDetectorRule
        """
        return pulumi.get(self, "recommendation")

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> Optional[str]:
        """
        resource type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "resource_type")

    @property
    @pulumi.getter(name="serviceType")
    def service_type(self) -> Optional[str]:
        """
        service type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "service_type")

    @property
    @pulumi.getter
    def state(self) -> Optional[str]:
        """
        (Updatable) The current state of the DetectorRule.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> Optional[str]:
        """
        The date and time the target was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> Optional[str]:
        """
        The date and time the target was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class TargetTargetDetectorRecipeDetectorRuleDetails(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "conditionGroups":
            suggest = "condition_groups"
        elif key == "isConfigurationAllowed":
            suggest = "is_configuration_allowed"
        elif key == "isEnabled":
            suggest = "is_enabled"
        elif key == "riskLevel":
            suggest = "risk_level"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TargetTargetDetectorRecipeDetectorRuleDetails. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TargetTargetDetectorRecipeDetectorRuleDetails.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TargetTargetDetectorRecipeDetectorRuleDetails.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition_groups: Optional[Sequence['outputs.TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroup']] = None,
                 configurations: Optional[Sequence['outputs.TargetTargetDetectorRecipeDetectorRuleDetailsConfiguration']] = None,
                 is_configuration_allowed: Optional[bool] = None,
                 is_enabled: Optional[bool] = None,
                 labels: Optional[Sequence[str]] = None,
                 risk_level: Optional[str] = None):
        """
        :param Sequence['TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroupArgs'] condition_groups: (Updatable) Condition group corresponding to each compartment
        :param Sequence['TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationArgs'] configurations: (Updatable) Configurations associated with the ResponderRule
        :param bool is_configuration_allowed: configuration allowed or not
        :param bool is_enabled: Identifies state for ResponderRule
        :param Sequence[str] labels: user defined labels for a detector rule
        :param str risk_level: The Risk Level
        """
        if condition_groups is not None:
            pulumi.set(__self__, "condition_groups", condition_groups)
        if configurations is not None:
            pulumi.set(__self__, "configurations", configurations)
        if is_configuration_allowed is not None:
            pulumi.set(__self__, "is_configuration_allowed", is_configuration_allowed)
        if is_enabled is not None:
            pulumi.set(__self__, "is_enabled", is_enabled)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if risk_level is not None:
            pulumi.set(__self__, "risk_level", risk_level)

    @property
    @pulumi.getter(name="conditionGroups")
    def condition_groups(self) -> Optional[Sequence['outputs.TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroup']]:
        """
        (Updatable) Condition group corresponding to each compartment
        """
        return pulumi.get(self, "condition_groups")

    @property
    @pulumi.getter
    def configurations(self) -> Optional[Sequence['outputs.TargetTargetDetectorRecipeDetectorRuleDetailsConfiguration']]:
        """
        (Updatable) Configurations associated with the ResponderRule
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isConfigurationAllowed")
    def is_configuration_allowed(self) -> Optional[bool]:
        """
        configuration allowed or not
        """
        return pulumi.get(self, "is_configuration_allowed")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> Optional[bool]:
        """
        Identifies state for ResponderRule
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Sequence[str]]:
        """
        user defined labels for a detector rule
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="riskLevel")
    def risk_level(self) -> Optional[str]:
        """
        The Risk Level
        """
        return pulumi.get(self, "risk_level")


@pulumi.output_type
class TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroup(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "compartmentId":
            suggest = "compartment_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroup. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroup.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroup.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 compartment_id: str,
                 condition: str):
        """
        :param str compartment_id: (Updatable) compartment associated with condition
        :param str condition: (Updatable)
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "condition", condition)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        (Updatable) compartment associated with condition
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def condition(self) -> str:
        """
        (Updatable)
        """
        return pulumi.get(self, "condition")


@pulumi.output_type
class TargetTargetDetectorRecipeDetectorRuleDetailsConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configKey":
            suggest = "config_key"
        elif key == "dataType":
            suggest = "data_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TargetTargetDetectorRecipeDetectorRuleDetailsConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TargetTargetDetectorRecipeDetectorRuleDetailsConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TargetTargetDetectorRecipeDetectorRuleDetailsConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 config_key: Optional[str] = None,
                 data_type: Optional[str] = None,
                 name: Optional[str] = None,
                 value: Optional[str] = None,
                 values: Optional[Sequence['outputs.TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValue']] = None):
        """
        :param str config_key: (Updatable) Unique name of the configuration
        :param str data_type: configuration data type
        :param str name: (Updatable) configuration name
        :param str value: (Updatable) configuration value
        :param Sequence['TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueArgs'] values: List of configuration values
        """
        if config_key is not None:
            pulumi.set(__self__, "config_key", config_key)
        if data_type is not None:
            pulumi.set(__self__, "data_type", data_type)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> Optional[str]:
        """
        (Updatable) Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter(name="dataType")
    def data_type(self) -> Optional[str]:
        """
        configuration data type
        """
        return pulumi.get(self, "data_type")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        (Updatable) configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        (Updatable) configuration value
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence['outputs.TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValue']]:
        """
        List of configuration values
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "listType":
            suggest = "list_type"
        elif key == "managedListType":
            suggest = "managed_list_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValue. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValue.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValue.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 list_type: Optional[str] = None,
                 managed_list_type: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str list_type: configuration list item type, either CUSTOM or MANAGED
        :param str managed_list_type: type of the managed list
        :param str value: (Updatable) configuration value
        """
        if list_type is not None:
            pulumi.set(__self__, "list_type", list_type)
        if managed_list_type is not None:
            pulumi.set(__self__, "managed_list_type", managed_list_type)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="listType")
    def list_type(self) -> Optional[str]:
        """
        configuration list item type, either CUSTOM or MANAGED
        """
        return pulumi.get(self, "list_type")

    @property
    @pulumi.getter(name="managedListType")
    def managed_list_type(self) -> Optional[str]:
        """
        type of the managed list
        """
        return pulumi.get(self, "managed_list_type")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        (Updatable) configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class TargetTargetDetectorRecipeEffectiveDetectorRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "detectorRuleId":
            suggest = "detector_rule_id"
        elif key == "displayName":
            suggest = "display_name"
        elif key == "lifecycleDetails":
            suggest = "lifecycle_details"
        elif key == "managedListTypes":
            suggest = "managed_list_types"
        elif key == "resourceType":
            suggest = "resource_type"
        elif key == "serviceType":
            suggest = "service_type"
        elif key == "timeCreated":
            suggest = "time_created"
        elif key == "timeUpdated":
            suggest = "time_updated"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TargetTargetDetectorRecipeEffectiveDetectorRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TargetTargetDetectorRecipeEffectiveDetectorRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TargetTargetDetectorRecipeEffectiveDetectorRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 description: Optional[str] = None,
                 details: Optional['outputs.TargetTargetDetectorRecipeEffectiveDetectorRuleDetails'] = None,
                 detector: Optional[str] = None,
                 detector_rule_id: Optional[str] = None,
                 display_name: Optional[str] = None,
                 lifecycle_details: Optional[str] = None,
                 managed_list_types: Optional[Sequence[str]] = None,
                 recommendation: Optional[str] = None,
                 resource_type: Optional[str] = None,
                 service_type: Optional[str] = None,
                 state: Optional[str] = None,
                 time_created: Optional[str] = None,
                 time_updated: Optional[str] = None):
        """
        :param str description: The target description.
        :param 'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsArgs' details: (Updatable) Details of ResponderRule.
        :param str detector: detector for the rule
        :param str detector_rule_id: (Updatable) Identifier for DetectorRule.
        :param str display_name: (Updatable) DetectorTemplate Identifier
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] managed_list_types: List of cloudguard managed list types related to this rule
        :param str recommendation: Recommendation for TargetDetectorRecipeDetectorRule
        :param str resource_type: resource type of the configuration to which the rule is applied
        :param str service_type: service type of the configuration to which the rule is applied
        :param str state: (Updatable) The current state of the DetectorRule.
        :param str time_created: The date and time the target was created. Format defined by RFC3339.
        :param str time_updated: The date and time the target was updated. Format defined by RFC3339.
        """
        if description is not None:
            pulumi.set(__self__, "description", description)
        if details is not None:
            pulumi.set(__self__, "details", details)
        if detector is not None:
            pulumi.set(__self__, "detector", detector)
        if detector_rule_id is not None:
            pulumi.set(__self__, "detector_rule_id", detector_rule_id)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if lifecycle_details is not None:
            pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        if managed_list_types is not None:
            pulumi.set(__self__, "managed_list_types", managed_list_types)
        if recommendation is not None:
            pulumi.set(__self__, "recommendation", recommendation)
        if resource_type is not None:
            pulumi.set(__self__, "resource_type", resource_type)
        if service_type is not None:
            pulumi.set(__self__, "service_type", service_type)
        if state is not None:
            pulumi.set(__self__, "state", state)
        if time_created is not None:
            pulumi.set(__self__, "time_created", time_created)
        if time_updated is not None:
            pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        The target description.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def details(self) -> Optional['outputs.TargetTargetDetectorRecipeEffectiveDetectorRuleDetails']:
        """
        (Updatable) Details of ResponderRule.
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter
    def detector(self) -> Optional[str]:
        """
        detector for the rule
        """
        return pulumi.get(self, "detector")

    @property
    @pulumi.getter(name="detectorRuleId")
    def detector_rule_id(self) -> Optional[str]:
        """
        (Updatable) Identifier for DetectorRule.
        """
        return pulumi.get(self, "detector_rule_id")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[str]:
        """
        (Updatable) DetectorTemplate Identifier
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> Optional[str]:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter(name="managedListTypes")
    def managed_list_types(self) -> Optional[Sequence[str]]:
        """
        List of cloudguard managed list types related to this rule
        """
        return pulumi.get(self, "managed_list_types")

    @property
    @pulumi.getter
    def recommendation(self) -> Optional[str]:
        """
        Recommendation for TargetDetectorRecipeDetectorRule
        """
        return pulumi.get(self, "recommendation")

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> Optional[str]:
        """
        resource type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "resource_type")

    @property
    @pulumi.getter(name="serviceType")
    def service_type(self) -> Optional[str]:
        """
        service type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "service_type")

    @property
    @pulumi.getter
    def state(self) -> Optional[str]:
        """
        (Updatable) The current state of the DetectorRule.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> Optional[str]:
        """
        The date and time the target was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> Optional[str]:
        """
        The date and time the target was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class TargetTargetDetectorRecipeEffectiveDetectorRuleDetails(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "conditionGroups":
            suggest = "condition_groups"
        elif key == "isConfigurationAllowed":
            suggest = "is_configuration_allowed"
        elif key == "isEnabled":
            suggest = "is_enabled"
        elif key == "riskLevel":
            suggest = "risk_level"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TargetTargetDetectorRecipeEffectiveDetectorRuleDetails. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TargetTargetDetectorRecipeEffectiveDetectorRuleDetails.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TargetTargetDetectorRecipeEffectiveDetectorRuleDetails.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition_groups: Optional[Sequence['outputs.TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConditionGroup']] = None,
                 configurations: Optional[Sequence['outputs.TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfiguration']] = None,
                 is_configuration_allowed: Optional[bool] = None,
                 is_enabled: Optional[bool] = None,
                 labels: Optional[Sequence[str]] = None,
                 risk_level: Optional[str] = None):
        """
        :param Sequence['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConditionGroupArgs'] condition_groups: (Updatable) Condition group corresponding to each compartment
        :param Sequence['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationArgs'] configurations: (Updatable) Configurations associated with the ResponderRule
        :param bool is_configuration_allowed: configuration allowed or not
        :param bool is_enabled: Identifies state for ResponderRule
        :param Sequence[str] labels: user defined labels for a detector rule
        :param str risk_level: The Risk Level
        """
        if condition_groups is not None:
            pulumi.set(__self__, "condition_groups", condition_groups)
        if configurations is not None:
            pulumi.set(__self__, "configurations", configurations)
        if is_configuration_allowed is not None:
            pulumi.set(__self__, "is_configuration_allowed", is_configuration_allowed)
        if is_enabled is not None:
            pulumi.set(__self__, "is_enabled", is_enabled)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if risk_level is not None:
            pulumi.set(__self__, "risk_level", risk_level)

    @property
    @pulumi.getter(name="conditionGroups")
    def condition_groups(self) -> Optional[Sequence['outputs.TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConditionGroup']]:
        """
        (Updatable) Condition group corresponding to each compartment
        """
        return pulumi.get(self, "condition_groups")

    @property
    @pulumi.getter
    def configurations(self) -> Optional[Sequence['outputs.TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfiguration']]:
        """
        (Updatable) Configurations associated with the ResponderRule
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isConfigurationAllowed")
    def is_configuration_allowed(self) -> Optional[bool]:
        """
        configuration allowed or not
        """
        return pulumi.get(self, "is_configuration_allowed")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> Optional[bool]:
        """
        Identifies state for ResponderRule
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Sequence[str]]:
        """
        user defined labels for a detector rule
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="riskLevel")
    def risk_level(self) -> Optional[str]:
        """
        The Risk Level
        """
        return pulumi.get(self, "risk_level")


@pulumi.output_type
class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConditionGroup(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "compartmentId":
            suggest = "compartment_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConditionGroup. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConditionGroup.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConditionGroup.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 compartment_id: Optional[str] = None,
                 condition: Optional[str] = None):
        """
        :param str compartment_id: (Updatable) compartment associated with condition
        :param str condition: (Updatable)
        """
        if compartment_id is not None:
            pulumi.set(__self__, "compartment_id", compartment_id)
        if condition is not None:
            pulumi.set(__self__, "condition", condition)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> Optional[str]:
        """
        (Updatable) compartment associated with condition
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def condition(self) -> Optional[str]:
        """
        (Updatable)
        """
        return pulumi.get(self, "condition")


@pulumi.output_type
class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configKey":
            suggest = "config_key"
        elif key == "dataType":
            suggest = "data_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 config_key: Optional[str] = None,
                 data_type: Optional[str] = None,
                 name: Optional[str] = None,
                 value: Optional[str] = None,
                 values: Optional[Sequence['outputs.TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValue']] = None):
        """
        :param str config_key: (Updatable) Unique name of the configuration
        :param str data_type: configuration data type
        :param str name: (Updatable) configuration name
        :param str value: (Updatable) configuration value
        :param Sequence['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValueArgs'] values: List of configuration values
        """
        if config_key is not None:
            pulumi.set(__self__, "config_key", config_key)
        if data_type is not None:
            pulumi.set(__self__, "data_type", data_type)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> Optional[str]:
        """
        (Updatable) Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter(name="dataType")
    def data_type(self) -> Optional[str]:
        """
        configuration data type
        """
        return pulumi.get(self, "data_type")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        (Updatable) configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        (Updatable) configuration value
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence['outputs.TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValue']]:
        """
        List of configuration values
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "listType":
            suggest = "list_type"
        elif key == "managedListType":
            suggest = "managed_list_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValue. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValue.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValue.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 list_type: Optional[str] = None,
                 managed_list_type: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str list_type: configuration list item type, either CUSTOM or MANAGED
        :param str managed_list_type: type of the managed list
        :param str value: (Updatable) configuration value
        """
        if list_type is not None:
            pulumi.set(__self__, "list_type", list_type)
        if managed_list_type is not None:
            pulumi.set(__self__, "managed_list_type", managed_list_type)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="listType")
    def list_type(self) -> Optional[str]:
        """
        configuration list item type, either CUSTOM or MANAGED
        """
        return pulumi.get(self, "list_type")

    @property
    @pulumi.getter(name="managedListType")
    def managed_list_type(self) -> Optional[str]:
        """
        type of the managed list
        """
        return pulumi.get(self, "managed_list_type")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        (Updatable) configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class TargetTargetResponderRecipe(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "responderRecipeId":
            suggest = "responder_recipe_id"
        elif key == "compartmentId":
            suggest = "compartment_id"
        elif key == "displayName":
            suggest = "display_name"
        elif key == "effectiveResponderRules":
            suggest = "effective_responder_rules"
        elif key == "responderRules":
            suggest = "responder_rules"
        elif key == "timeCreated":
            suggest = "time_created"
        elif key == "timeUpdated":
            suggest = "time_updated"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TargetTargetResponderRecipe. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TargetTargetResponderRecipe.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TargetTargetResponderRecipe.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 responder_recipe_id: str,
                 compartment_id: Optional[str] = None,
                 description: Optional[str] = None,
                 display_name: Optional[str] = None,
                 effective_responder_rules: Optional[Sequence['outputs.TargetTargetResponderRecipeEffectiveResponderRule']] = None,
                 id: Optional[str] = None,
                 owner: Optional[str] = None,
                 responder_rules: Optional[Sequence['outputs.TargetTargetResponderRecipeResponderRule']] = None,
                 time_created: Optional[str] = None,
                 time_updated: Optional[str] = None):
        """
        :param str responder_recipe_id: Identifier for ResponderRecipe.
        :param str compartment_id: (Updatable) compartment associated with condition
        :param str description: The target description.
        :param str display_name: (Updatable) DetectorTemplate Identifier
        :param Sequence['TargetTargetResponderRecipeEffectiveResponderRuleArgs'] effective_responder_rules: List of responder rules associated with the recipe after applying all defaults
        :param str id: Unique identifier of TargetResponderRecipe that is immutable on creation
        :param str owner: Owner of ResponderRecipe
        :param Sequence['TargetTargetResponderRecipeResponderRuleArgs'] responder_rules: (Updatable) Override responder rules associated with reponder recipe in a target.
        :param str time_created: The date and time the target was created. Format defined by RFC3339.
        :param str time_updated: The date and time the target was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "responder_recipe_id", responder_recipe_id)
        if compartment_id is not None:
            pulumi.set(__self__, "compartment_id", compartment_id)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if effective_responder_rules is not None:
            pulumi.set(__self__, "effective_responder_rules", effective_responder_rules)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if owner is not None:
            pulumi.set(__self__, "owner", owner)
        if responder_rules is not None:
            pulumi.set(__self__, "responder_rules", responder_rules)
        if time_created is not None:
            pulumi.set(__self__, "time_created", time_created)
        if time_updated is not None:
            pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter(name="responderRecipeId")
    def responder_recipe_id(self) -> str:
        """
        Identifier for ResponderRecipe.
        """
        return pulumi.get(self, "responder_recipe_id")

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> Optional[str]:
        """
        (Updatable) compartment associated with condition
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        The target description.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[str]:
        """
        (Updatable) DetectorTemplate Identifier
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="effectiveResponderRules")
    def effective_responder_rules(self) -> Optional[Sequence['outputs.TargetTargetResponderRecipeEffectiveResponderRule']]:
        """
        List of responder rules associated with the recipe after applying all defaults
        """
        return pulumi.get(self, "effective_responder_rules")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Unique identifier of TargetResponderRecipe that is immutable on creation
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def owner(self) -> Optional[str]:
        """
        Owner of ResponderRecipe
        """
        return pulumi.get(self, "owner")

    @property
    @pulumi.getter(name="responderRules")
    def responder_rules(self) -> Optional[Sequence['outputs.TargetTargetResponderRecipeResponderRule']]:
        """
        (Updatable) Override responder rules associated with reponder recipe in a target.
        """
        return pulumi.get(self, "responder_rules")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> Optional[str]:
        """
        The date and time the target was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> Optional[str]:
        """
        The date and time the target was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class TargetTargetResponderRecipeEffectiveResponderRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "compartmentId":
            suggest = "compartment_id"
        elif key == "displayName":
            suggest = "display_name"
        elif key == "lifecycleDetails":
            suggest = "lifecycle_details"
        elif key == "responderRuleId":
            suggest = "responder_rule_id"
        elif key == "supportedModes":
            suggest = "supported_modes"
        elif key == "timeCreated":
            suggest = "time_created"
        elif key == "timeUpdated":
            suggest = "time_updated"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TargetTargetResponderRecipeEffectiveResponderRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TargetTargetResponderRecipeEffectiveResponderRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TargetTargetResponderRecipeEffectiveResponderRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 compartment_id: Optional[str] = None,
                 description: Optional[str] = None,
                 details: Optional['outputs.TargetTargetResponderRecipeEffectiveResponderRuleDetails'] = None,
                 display_name: Optional[str] = None,
                 lifecycle_details: Optional[str] = None,
                 policies: Optional[Sequence[str]] = None,
                 responder_rule_id: Optional[str] = None,
                 state: Optional[str] = None,
                 supported_modes: Optional[Sequence[str]] = None,
                 time_created: Optional[str] = None,
                 time_updated: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param str compartment_id: (Updatable) compartment associated with condition
        :param str description: The target description.
        :param 'TargetTargetResponderRecipeEffectiveResponderRuleDetailsArgs' details: (Updatable) Details of ResponderRule.
        :param str display_name: (Updatable) DetectorTemplate Identifier
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] policies: List of Policy
        :param str responder_rule_id: (Updatable) Identifier for ResponderRule.
        :param str state: (Updatable) The current state of the DetectorRule.
        :param Sequence[str] supported_modes: Supported Execution Modes
        :param str time_created: The date and time the target was created. Format defined by RFC3339.
        :param str time_updated: The date and time the target was updated. Format defined by RFC3339.
        :param str type: Type of Responder
        """
        if compartment_id is not None:
            pulumi.set(__self__, "compartment_id", compartment_id)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if details is not None:
            pulumi.set(__self__, "details", details)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if lifecycle_details is not None:
            pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        if policies is not None:
            pulumi.set(__self__, "policies", policies)
        if responder_rule_id is not None:
            pulumi.set(__self__, "responder_rule_id", responder_rule_id)
        if state is not None:
            pulumi.set(__self__, "state", state)
        if supported_modes is not None:
            pulumi.set(__self__, "supported_modes", supported_modes)
        if time_created is not None:
            pulumi.set(__self__, "time_created", time_created)
        if time_updated is not None:
            pulumi.set(__self__, "time_updated", time_updated)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> Optional[str]:
        """
        (Updatable) compartment associated with condition
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        The target description.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def details(self) -> Optional['outputs.TargetTargetResponderRecipeEffectiveResponderRuleDetails']:
        """
        (Updatable) Details of ResponderRule.
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[str]:
        """
        (Updatable) DetectorTemplate Identifier
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> Optional[str]:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter
    def policies(self) -> Optional[Sequence[str]]:
        """
        List of Policy
        """
        return pulumi.get(self, "policies")

    @property
    @pulumi.getter(name="responderRuleId")
    def responder_rule_id(self) -> Optional[str]:
        """
        (Updatable) Identifier for ResponderRule.
        """
        return pulumi.get(self, "responder_rule_id")

    @property
    @pulumi.getter
    def state(self) -> Optional[str]:
        """
        (Updatable) The current state of the DetectorRule.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="supportedModes")
    def supported_modes(self) -> Optional[Sequence[str]]:
        """
        Supported Execution Modes
        """
        return pulumi.get(self, "supported_modes")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> Optional[str]:
        """
        The date and time the target was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> Optional[str]:
        """
        The date and time the target was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        Type of Responder
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class TargetTargetResponderRecipeEffectiveResponderRuleDetails(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isEnabled":
            suggest = "is_enabled"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TargetTargetResponderRecipeEffectiveResponderRuleDetails. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TargetTargetResponderRecipeEffectiveResponderRuleDetails.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TargetTargetResponderRecipeEffectiveResponderRuleDetails.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition: Optional[str] = None,
                 configurations: Optional[Sequence['outputs.TargetTargetResponderRecipeEffectiveResponderRuleDetailsConfiguration']] = None,
                 is_enabled: Optional[bool] = None,
                 mode: Optional[str] = None):
        """
        :param str condition: (Updatable)
        :param Sequence['TargetTargetResponderRecipeEffectiveResponderRuleDetailsConfigurationArgs'] configurations: (Updatable) Configurations associated with the ResponderRule
        :param bool is_enabled: Identifies state for ResponderRule
        :param str mode: (Updatable) Execution Mode for ResponderRule
        """
        if condition is not None:
            pulumi.set(__self__, "condition", condition)
        if configurations is not None:
            pulumi.set(__self__, "configurations", configurations)
        if is_enabled is not None:
            pulumi.set(__self__, "is_enabled", is_enabled)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def condition(self) -> Optional[str]:
        """
        (Updatable)
        """
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter
    def configurations(self) -> Optional[Sequence['outputs.TargetTargetResponderRecipeEffectiveResponderRuleDetailsConfiguration']]:
        """
        (Updatable) Configurations associated with the ResponderRule
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> Optional[bool]:
        """
        Identifies state for ResponderRule
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def mode(self) -> Optional[str]:
        """
        (Updatable) Execution Mode for ResponderRule
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class TargetTargetResponderRecipeEffectiveResponderRuleDetailsConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configKey":
            suggest = "config_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TargetTargetResponderRecipeEffectiveResponderRuleDetailsConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TargetTargetResponderRecipeEffectiveResponderRuleDetailsConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TargetTargetResponderRecipeEffectiveResponderRuleDetailsConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 config_key: Optional[str] = None,
                 name: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str config_key: (Updatable) Unique name of the configuration
        :param str name: (Updatable) configuration name
        :param str value: (Updatable) configuration value
        """
        if config_key is not None:
            pulumi.set(__self__, "config_key", config_key)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> Optional[str]:
        """
        (Updatable) Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        (Updatable) configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        (Updatable) configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class TargetTargetResponderRecipeResponderRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "responderRuleId":
            suggest = "responder_rule_id"
        elif key == "compartmentId":
            suggest = "compartment_id"
        elif key == "displayName":
            suggest = "display_name"
        elif key == "lifecycleDetails":
            suggest = "lifecycle_details"
        elif key == "supportedModes":
            suggest = "supported_modes"
        elif key == "timeCreated":
            suggest = "time_created"
        elif key == "timeUpdated":
            suggest = "time_updated"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TargetTargetResponderRecipeResponderRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TargetTargetResponderRecipeResponderRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TargetTargetResponderRecipeResponderRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 details: 'outputs.TargetTargetResponderRecipeResponderRuleDetails',
                 responder_rule_id: str,
                 compartment_id: Optional[str] = None,
                 description: Optional[str] = None,
                 display_name: Optional[str] = None,
                 lifecycle_details: Optional[str] = None,
                 policies: Optional[Sequence[str]] = None,
                 state: Optional[str] = None,
                 supported_modes: Optional[Sequence[str]] = None,
                 time_created: Optional[str] = None,
                 time_updated: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param 'TargetTargetResponderRecipeResponderRuleDetailsArgs' details: (Updatable) Details of ResponderRule.
        :param str responder_rule_id: (Updatable) Identifier for ResponderRule.
        :param str compartment_id: (Updatable) compartment associated with condition
        :param str description: The target description.
        :param str display_name: (Updatable) DetectorTemplate Identifier
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] policies: List of Policy
        :param str state: (Updatable) The current state of the DetectorRule.
        :param Sequence[str] supported_modes: Supported Execution Modes
        :param str time_created: The date and time the target was created. Format defined by RFC3339.
        :param str time_updated: The date and time the target was updated. Format defined by RFC3339.
        :param str type: Type of Responder
        """
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "responder_rule_id", responder_rule_id)
        if compartment_id is not None:
            pulumi.set(__self__, "compartment_id", compartment_id)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if lifecycle_details is not None:
            pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        if policies is not None:
            pulumi.set(__self__, "policies", policies)
        if state is not None:
            pulumi.set(__self__, "state", state)
        if supported_modes is not None:
            pulumi.set(__self__, "supported_modes", supported_modes)
        if time_created is not None:
            pulumi.set(__self__, "time_created", time_created)
        if time_updated is not None:
            pulumi.set(__self__, "time_updated", time_updated)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def details(self) -> 'outputs.TargetTargetResponderRecipeResponderRuleDetails':
        """
        (Updatable) Details of ResponderRule.
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter(name="responderRuleId")
    def responder_rule_id(self) -> str:
        """
        (Updatable) Identifier for ResponderRule.
        """
        return pulumi.get(self, "responder_rule_id")

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> Optional[str]:
        """
        (Updatable) compartment associated with condition
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        The target description.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[str]:
        """
        (Updatable) DetectorTemplate Identifier
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> Optional[str]:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter
    def policies(self) -> Optional[Sequence[str]]:
        """
        List of Policy
        """
        return pulumi.get(self, "policies")

    @property
    @pulumi.getter
    def state(self) -> Optional[str]:
        """
        (Updatable) The current state of the DetectorRule.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="supportedModes")
    def supported_modes(self) -> Optional[Sequence[str]]:
        """
        Supported Execution Modes
        """
        return pulumi.get(self, "supported_modes")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> Optional[str]:
        """
        The date and time the target was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> Optional[str]:
        """
        The date and time the target was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        Type of Responder
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class TargetTargetResponderRecipeResponderRuleDetails(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isEnabled":
            suggest = "is_enabled"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TargetTargetResponderRecipeResponderRuleDetails. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TargetTargetResponderRecipeResponderRuleDetails.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TargetTargetResponderRecipeResponderRuleDetails.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition: Optional[str] = None,
                 configurations: Optional[Sequence['outputs.TargetTargetResponderRecipeResponderRuleDetailsConfiguration']] = None,
                 is_enabled: Optional[bool] = None,
                 mode: Optional[str] = None):
        """
        :param str condition: (Updatable)
        :param Sequence['TargetTargetResponderRecipeResponderRuleDetailsConfigurationArgs'] configurations: (Updatable) Configurations associated with the ResponderRule
        :param bool is_enabled: Identifies state for ResponderRule
        :param str mode: (Updatable) Execution Mode for ResponderRule
        """
        if condition is not None:
            pulumi.set(__self__, "condition", condition)
        if configurations is not None:
            pulumi.set(__self__, "configurations", configurations)
        if is_enabled is not None:
            pulumi.set(__self__, "is_enabled", is_enabled)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def condition(self) -> Optional[str]:
        """
        (Updatable)
        """
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter
    def configurations(self) -> Optional[Sequence['outputs.TargetTargetResponderRecipeResponderRuleDetailsConfiguration']]:
        """
        (Updatable) Configurations associated with the ResponderRule
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> Optional[bool]:
        """
        Identifies state for ResponderRule
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def mode(self) -> Optional[str]:
        """
        (Updatable) Execution Mode for ResponderRule
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class TargetTargetResponderRecipeResponderRuleDetailsConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configKey":
            suggest = "config_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TargetTargetResponderRecipeResponderRuleDetailsConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TargetTargetResponderRecipeResponderRuleDetailsConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TargetTargetResponderRecipeResponderRuleDetailsConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 config_key: str,
                 name: str,
                 value: str):
        """
        :param str config_key: (Updatable) Unique name of the configuration
        :param str name: (Updatable) configuration name
        :param str value: (Updatable) configuration value
        """
        pulumi.set(__self__, "config_key", config_key)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> str:
        """
        (Updatable) Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        (Updatable) configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        (Updatable) configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetDataMaskRuleTargetSelectedResult(dict):
    def __init__(__self__, *,
                 kind: str,
                 values: Sequence[str]):
        """
        :param str kind: Target selection.
        :param Sequence[str] values: Types of Targets
        """
        pulumi.set(__self__, "kind", kind)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def kind(self) -> str:
        """
        Target selection.
        """
        return pulumi.get(self, "kind")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        Types of Targets
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class GetDataMaskRulesDataMaskRuleCollectionResult(dict):
    def __init__(__self__, *,
                 items: Sequence['outputs.GetDataMaskRulesDataMaskRuleCollectionItemResult']):
        pulumi.set(__self__, "items", items)

    @property
    @pulumi.getter
    def items(self) -> Sequence['outputs.GetDataMaskRulesDataMaskRuleCollectionItemResult']:
        return pulumi.get(self, "items")


@pulumi.output_type
class GetDataMaskRulesDataMaskRuleCollectionItemResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 data_mask_categories: Sequence[str],
                 data_mask_rule_status: str,
                 defined_tags: Mapping[str, Any],
                 description: str,
                 display_name: str,
                 freeform_tags: Mapping[str, Any],
                 iam_group_id: str,
                 id: str,
                 lifecyle_details: str,
                 state: str,
                 system_tags: Mapping[str, Any],
                 target_selected: 'outputs.GetDataMaskRulesDataMaskRuleCollectionItemTargetSelectedResult',
                 time_created: str,
                 time_updated: str):
        """
        :param str compartment_id: The ID of the compartment in which to list resources.
        :param Sequence[str] data_mask_categories: Data Mask Categories
        :param str data_mask_rule_status: The status of the dataMaskRule.
        :param Mapping[str, Any] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
        :param str description: The data mask rule description.
        :param str display_name: A filter to return only resources that match the entire display name given.
        :param Mapping[str, Any] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
        :param str iam_group_id: OCID of iamGroup
        :param str id: Unique identifier that is immutable on creation
        :param str lifecyle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param str state: The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        :param Mapping[str, Any] system_tags: System tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). System tags can be viewed by users, but can only be created by the system.  Example: `{"orcl-cloud.free-tier-retained": "true"}`
        :param 'GetDataMaskRulesDataMaskRuleCollectionItemTargetSelectedArgs' target_selected: Target Selection eg select ALL or select on basis of TargetResourceTypes or TargetIds.
        :param str time_created: The date and time the target was created. Format defined by RFC3339.
        :param str time_updated: The date and time the target was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "data_mask_categories", data_mask_categories)
        pulumi.set(__self__, "data_mask_rule_status", data_mask_rule_status)
        pulumi.set(__self__, "defined_tags", defined_tags)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "freeform_tags", freeform_tags)
        pulumi.set(__self__, "iam_group_id", iam_group_id)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "lifecyle_details", lifecyle_details)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "system_tags", system_tags)
        pulumi.set(__self__, "target_selected", target_selected)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        The ID of the compartment in which to list resources.
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter(name="dataMaskCategories")
    def data_mask_categories(self) -> Sequence[str]:
        """
        Data Mask Categories
        """
        return pulumi.get(self, "data_mask_categories")

    @property
    @pulumi.getter(name="dataMaskRuleStatus")
    def data_mask_rule_status(self) -> str:
        """
        The status of the dataMaskRule.
        """
        return pulumi.get(self, "data_mask_rule_status")

    @property
    @pulumi.getter(name="definedTags")
    def defined_tags(self) -> Mapping[str, Any]:
        """
        Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
        """
        return pulumi.get(self, "defined_tags")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        The data mask rule description.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        A filter to return only resources that match the entire display name given.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="freeformTags")
    def freeform_tags(self) -> Mapping[str, Any]:
        """
        Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
        """
        return pulumi.get(self, "freeform_tags")

    @property
    @pulumi.getter(name="iamGroupId")
    def iam_group_id(self) -> str:
        """
        OCID of iamGroup
        """
        return pulumi.get(self, "iam_group_id")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Unique identifier that is immutable on creation
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="lifecyleDetails")
    def lifecyle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecyle_details")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="systemTags")
    def system_tags(self) -> Mapping[str, Any]:
        """
        System tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). System tags can be viewed by users, but can only be created by the system.  Example: `{"orcl-cloud.free-tier-retained": "true"}`
        """
        return pulumi.get(self, "system_tags")

    @property
    @pulumi.getter(name="targetSelected")
    def target_selected(self) -> 'outputs.GetDataMaskRulesDataMaskRuleCollectionItemTargetSelectedResult':
        """
        Target Selection eg select ALL or select on basis of TargetResourceTypes or TargetIds.
        """
        return pulumi.get(self, "target_selected")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the target was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the target was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class GetDataMaskRulesDataMaskRuleCollectionItemTargetSelectedResult(dict):
    def __init__(__self__, *,
                 kind: str,
                 values: Sequence[str]):
        """
        :param str kind: Target selection.
        :param Sequence[str] values: Types of Targets
        """
        pulumi.set(__self__, "kind", kind)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def kind(self) -> str:
        """
        Target selection.
        """
        return pulumi.get(self, "kind")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        Types of Targets
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class GetDataMaskRulesFilterResult(dict):
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str],
                 regex: Optional[bool] = None):
        """
        :param Sequence[str] values: Types of Targets
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)
        if regex is not None:
            pulumi.set(__self__, "regex", regex)

    @property
    @pulumi.getter
    def name(self) -> str:
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        Types of Targets
        """
        return pulumi.get(self, "values")

    @property
    @pulumi.getter
    def regex(self) -> Optional[bool]:
        return pulumi.get(self, "regex")


@pulumi.output_type
class GetDetectorRecipeDetectorRuleResult(dict):
    def __init__(__self__, *,
                 candidate_responder_rules: Sequence['outputs.GetDetectorRecipeDetectorRuleCandidateResponderRuleResult'],
                 description: str,
                 details: 'outputs.GetDetectorRecipeDetectorRuleDetailsResult',
                 detector: str,
                 detector_rule_id: str,
                 display_name: str,
                 lifecycle_details: str,
                 managed_list_types: Sequence[str],
                 recommendation: str,
                 resource_type: str,
                 service_type: str,
                 state: str,
                 time_created: str,
                 time_updated: str):
        """
        :param Sequence['GetDetectorRecipeDetectorRuleCandidateResponderRuleArgs'] candidate_responder_rules: List of CandidateResponderRule related to this rule
        :param str description: Description for DetectorRecipeDetectorRule
        :param 'GetDetectorRecipeDetectorRuleDetailsArgs' details: Details of a Detector Rule
        :param str detector: detector for the rule
        :param str detector_rule_id: The unique identifier of the detector rule
        :param str display_name: displayName
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] managed_list_types: List of cloudguard managed list types related to this rule
        :param str recommendation: Recommendation for DetectorRecipeDetectorRule
        :param str resource_type: resource type of the configuration to which the rule is applied
        :param str service_type: service type of the configuration to which the rule is applied
        :param str state: The current state of the resource.
        :param str time_created: The date and time the detector recipe was created. Format defined by RFC3339.
        :param str time_updated: The date and time the detector recipe was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "candidate_responder_rules", candidate_responder_rules)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "detector", detector)
        pulumi.set(__self__, "detector_rule_id", detector_rule_id)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        pulumi.set(__self__, "managed_list_types", managed_list_types)
        pulumi.set(__self__, "recommendation", recommendation)
        pulumi.set(__self__, "resource_type", resource_type)
        pulumi.set(__self__, "service_type", service_type)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter(name="candidateResponderRules")
    def candidate_responder_rules(self) -> Sequence['outputs.GetDetectorRecipeDetectorRuleCandidateResponderRuleResult']:
        """
        List of CandidateResponderRule related to this rule
        """
        return pulumi.get(self, "candidate_responder_rules")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        Description for DetectorRecipeDetectorRule
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def details(self) -> 'outputs.GetDetectorRecipeDetectorRuleDetailsResult':
        """
        Details of a Detector Rule
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter
    def detector(self) -> str:
        """
        detector for the rule
        """
        return pulumi.get(self, "detector")

    @property
    @pulumi.getter(name="detectorRuleId")
    def detector_rule_id(self) -> str:
        """
        The unique identifier of the detector rule
        """
        return pulumi.get(self, "detector_rule_id")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        displayName
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter(name="managedListTypes")
    def managed_list_types(self) -> Sequence[str]:
        """
        List of cloudguard managed list types related to this rule
        """
        return pulumi.get(self, "managed_list_types")

    @property
    @pulumi.getter
    def recommendation(self) -> str:
        """
        Recommendation for DetectorRecipeDetectorRule
        """
        return pulumi.get(self, "recommendation")

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> str:
        """
        resource type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "resource_type")

    @property
    @pulumi.getter(name="serviceType")
    def service_type(self) -> str:
        """
        service type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "service_type")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The current state of the resource.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the detector recipe was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the detector recipe was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class GetDetectorRecipeDetectorRuleCandidateResponderRuleResult(dict):
    def __init__(__self__, *,
                 display_name: str,
                 id: str,
                 is_preferred: bool):
        """
        :param str display_name: displayName
        :param str id: Ocid for detector recipe
        :param bool is_preferred: Preferred state
        """
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_preferred", is_preferred)

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        displayName
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Ocid for detector recipe
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="isPreferred")
    def is_preferred(self) -> bool:
        """
        Preferred state
        """
        return pulumi.get(self, "is_preferred")


@pulumi.output_type
class GetDetectorRecipeDetectorRuleDetailsResult(dict):
    def __init__(__self__, *,
                 condition: str,
                 configurations: Sequence['outputs.GetDetectorRecipeDetectorRuleDetailsConfigurationResult'],
                 is_configuration_allowed: bool,
                 is_enabled: bool,
                 labels: Sequence[str],
                 risk_level: str):
        """
        :param Sequence['GetDetectorRecipeDetectorRuleDetailsConfigurationArgs'] configurations: Configuration details
        :param bool is_configuration_allowed: configuration allowed or not
        :param bool is_enabled: Enables the control
        :param Sequence[str] labels: user defined labels for a detector rule
        :param str risk_level: The Risk Level
        """
        pulumi.set(__self__, "condition", condition)
        pulumi.set(__self__, "configurations", configurations)
        pulumi.set(__self__, "is_configuration_allowed", is_configuration_allowed)
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "risk_level", risk_level)

    @property
    @pulumi.getter
    def condition(self) -> str:
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter
    def configurations(self) -> Sequence['outputs.GetDetectorRecipeDetectorRuleDetailsConfigurationResult']:
        """
        Configuration details
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isConfigurationAllowed")
    def is_configuration_allowed(self) -> bool:
        """
        configuration allowed or not
        """
        return pulumi.get(self, "is_configuration_allowed")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        """
        Enables the control
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def labels(self) -> Sequence[str]:
        """
        user defined labels for a detector rule
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="riskLevel")
    def risk_level(self) -> str:
        """
        The Risk Level
        """
        return pulumi.get(self, "risk_level")


@pulumi.output_type
class GetDetectorRecipeDetectorRuleDetailsConfigurationResult(dict):
    def __init__(__self__, *,
                 config_key: str,
                 data_type: str,
                 name: str,
                 value: str,
                 values: Sequence['outputs.GetDetectorRecipeDetectorRuleDetailsConfigurationValueResult']):
        """
        :param str config_key: Unique name of the configuration
        :param str data_type: configuration data type
        :param str name: configuration name
        :param str value: configuration value
        :param Sequence['GetDetectorRecipeDetectorRuleDetailsConfigurationValueArgs'] values: List of configuration values
        """
        pulumi.set(__self__, "config_key", config_key)
        pulumi.set(__self__, "data_type", data_type)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> str:
        """
        Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter(name="dataType")
    def data_type(self) -> str:
        """
        configuration data type
        """
        return pulumi.get(self, "data_type")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def values(self) -> Sequence['outputs.GetDetectorRecipeDetectorRuleDetailsConfigurationValueResult']:
        """
        List of configuration values
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class GetDetectorRecipeDetectorRuleDetailsConfigurationValueResult(dict):
    def __init__(__self__, *,
                 list_type: str,
                 managed_list_type: str,
                 value: str):
        """
        :param str list_type: configuration list item type, either CUSTOM or MANAGED
        :param str managed_list_type: type of the managed list
        :param str value: configuration value
        """
        pulumi.set(__self__, "list_type", list_type)
        pulumi.set(__self__, "managed_list_type", managed_list_type)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="listType")
    def list_type(self) -> str:
        """
        configuration list item type, either CUSTOM or MANAGED
        """
        return pulumi.get(self, "list_type")

    @property
    @pulumi.getter(name="managedListType")
    def managed_list_type(self) -> str:
        """
        type of the managed list
        """
        return pulumi.get(self, "managed_list_type")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetDetectorRecipeEffectiveDetectorRuleResult(dict):
    def __init__(__self__, *,
                 candidate_responder_rules: Sequence['outputs.GetDetectorRecipeEffectiveDetectorRuleCandidateResponderRuleResult'],
                 description: str,
                 details: 'outputs.GetDetectorRecipeEffectiveDetectorRuleDetailsResult',
                 detector: str,
                 detector_rule_id: str,
                 display_name: str,
                 lifecycle_details: str,
                 managed_list_types: Sequence[str],
                 recommendation: str,
                 resource_type: str,
                 service_type: str,
                 state: str,
                 time_created: str,
                 time_updated: str):
        """
        :param Sequence['GetDetectorRecipeEffectiveDetectorRuleCandidateResponderRuleArgs'] candidate_responder_rules: List of CandidateResponderRule related to this rule
        :param str description: Description for DetectorRecipeDetectorRule
        :param 'GetDetectorRecipeEffectiveDetectorRuleDetailsArgs' details: Details of a Detector Rule
        :param str detector: detector for the rule
        :param str detector_rule_id: The unique identifier of the detector rule
        :param str display_name: displayName
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] managed_list_types: List of cloudguard managed list types related to this rule
        :param str recommendation: Recommendation for DetectorRecipeDetectorRule
        :param str resource_type: resource type of the configuration to which the rule is applied
        :param str service_type: service type of the configuration to which the rule is applied
        :param str state: The current state of the resource.
        :param str time_created: The date and time the detector recipe was created. Format defined by RFC3339.
        :param str time_updated: The date and time the detector recipe was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "candidate_responder_rules", candidate_responder_rules)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "detector", detector)
        pulumi.set(__self__, "detector_rule_id", detector_rule_id)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        pulumi.set(__self__, "managed_list_types", managed_list_types)
        pulumi.set(__self__, "recommendation", recommendation)
        pulumi.set(__self__, "resource_type", resource_type)
        pulumi.set(__self__, "service_type", service_type)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter(name="candidateResponderRules")
    def candidate_responder_rules(self) -> Sequence['outputs.GetDetectorRecipeEffectiveDetectorRuleCandidateResponderRuleResult']:
        """
        List of CandidateResponderRule related to this rule
        """
        return pulumi.get(self, "candidate_responder_rules")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        Description for DetectorRecipeDetectorRule
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def details(self) -> 'outputs.GetDetectorRecipeEffectiveDetectorRuleDetailsResult':
        """
        Details of a Detector Rule
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter
    def detector(self) -> str:
        """
        detector for the rule
        """
        return pulumi.get(self, "detector")

    @property
    @pulumi.getter(name="detectorRuleId")
    def detector_rule_id(self) -> str:
        """
        The unique identifier of the detector rule
        """
        return pulumi.get(self, "detector_rule_id")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        displayName
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter(name="managedListTypes")
    def managed_list_types(self) -> Sequence[str]:
        """
        List of cloudguard managed list types related to this rule
        """
        return pulumi.get(self, "managed_list_types")

    @property
    @pulumi.getter
    def recommendation(self) -> str:
        """
        Recommendation for DetectorRecipeDetectorRule
        """
        return pulumi.get(self, "recommendation")

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> str:
        """
        resource type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "resource_type")

    @property
    @pulumi.getter(name="serviceType")
    def service_type(self) -> str:
        """
        service type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "service_type")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The current state of the resource.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the detector recipe was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the detector recipe was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class GetDetectorRecipeEffectiveDetectorRuleCandidateResponderRuleResult(dict):
    def __init__(__self__, *,
                 display_name: str,
                 id: str,
                 is_preferred: bool):
        """
        :param str display_name: displayName
        :param str id: Ocid for detector recipe
        :param bool is_preferred: Preferred state
        """
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_preferred", is_preferred)

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        displayName
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Ocid for detector recipe
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="isPreferred")
    def is_preferred(self) -> bool:
        """
        Preferred state
        """
        return pulumi.get(self, "is_preferred")


@pulumi.output_type
class GetDetectorRecipeEffectiveDetectorRuleDetailsResult(dict):
    def __init__(__self__, *,
                 condition: str,
                 configurations: Sequence['outputs.GetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationResult'],
                 is_configuration_allowed: bool,
                 is_enabled: bool,
                 labels: Sequence[str],
                 risk_level: str):
        """
        :param Sequence['GetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationArgs'] configurations: Configuration details
        :param bool is_configuration_allowed: configuration allowed or not
        :param bool is_enabled: Enables the control
        :param Sequence[str] labels: user defined labels for a detector rule
        :param str risk_level: The Risk Level
        """
        pulumi.set(__self__, "condition", condition)
        pulumi.set(__self__, "configurations", configurations)
        pulumi.set(__self__, "is_configuration_allowed", is_configuration_allowed)
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "risk_level", risk_level)

    @property
    @pulumi.getter
    def condition(self) -> str:
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter
    def configurations(self) -> Sequence['outputs.GetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationResult']:
        """
        Configuration details
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isConfigurationAllowed")
    def is_configuration_allowed(self) -> bool:
        """
        configuration allowed or not
        """
        return pulumi.get(self, "is_configuration_allowed")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        """
        Enables the control
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def labels(self) -> Sequence[str]:
        """
        user defined labels for a detector rule
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="riskLevel")
    def risk_level(self) -> str:
        """
        The Risk Level
        """
        return pulumi.get(self, "risk_level")


@pulumi.output_type
class GetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationResult(dict):
    def __init__(__self__, *,
                 config_key: str,
                 data_type: str,
                 name: str,
                 value: str,
                 values: Sequence['outputs.GetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValueResult']):
        """
        :param str config_key: Unique name of the configuration
        :param str data_type: configuration data type
        :param str name: configuration name
        :param str value: configuration value
        :param Sequence['GetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValueArgs'] values: List of configuration values
        """
        pulumi.set(__self__, "config_key", config_key)
        pulumi.set(__self__, "data_type", data_type)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> str:
        """
        Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter(name="dataType")
    def data_type(self) -> str:
        """
        configuration data type
        """
        return pulumi.get(self, "data_type")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def values(self) -> Sequence['outputs.GetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValueResult']:
        """
        List of configuration values
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class GetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValueResult(dict):
    def __init__(__self__, *,
                 list_type: str,
                 managed_list_type: str,
                 value: str):
        """
        :param str list_type: configuration list item type, either CUSTOM or MANAGED
        :param str managed_list_type: type of the managed list
        :param str value: configuration value
        """
        pulumi.set(__self__, "list_type", list_type)
        pulumi.set(__self__, "managed_list_type", managed_list_type)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="listType")
    def list_type(self) -> str:
        """
        configuration list item type, either CUSTOM or MANAGED
        """
        return pulumi.get(self, "list_type")

    @property
    @pulumi.getter(name="managedListType")
    def managed_list_type(self) -> str:
        """
        type of the managed list
        """
        return pulumi.get(self, "managed_list_type")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetDetectorRecipesDetectorRecipeCollectionResult(dict):
    def __init__(__self__, *,
                 items: Sequence['outputs.GetDetectorRecipesDetectorRecipeCollectionItemResult']):
        pulumi.set(__self__, "items", items)

    @property
    @pulumi.getter
    def items(self) -> Sequence['outputs.GetDetectorRecipesDetectorRecipeCollectionItemResult']:
        return pulumi.get(self, "items")


@pulumi.output_type
class GetDetectorRecipesDetectorRecipeCollectionItemResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 defined_tags: Mapping[str, Any],
                 description: str,
                 detector: str,
                 detector_rules: Sequence['outputs.GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleResult'],
                 display_name: str,
                 effective_detector_rules: Sequence['outputs.GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleResult'],
                 freeform_tags: Mapping[str, Any],
                 id: str,
                 owner: str,
                 source_detector_recipe_id: str,
                 state: str,
                 system_tags: Mapping[str, Any],
                 time_created: str,
                 time_updated: str):
        """
        :param str compartment_id: The ID of the compartment in which to list resources.
        :param Mapping[str, Any] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
        :param str description: Description for DetectorRecipeDetectorRule
        :param str detector: detector for the rule
        :param Sequence['GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleArgs'] detector_rules: List of detector rules for the detector type for recipe - user input
        :param str display_name: A filter to return only resources that match the entire display name given.
        :param Sequence['GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleArgs'] effective_detector_rules: List of effective detector rules for the detector type for recipe after applying defaults
        :param Mapping[str, Any] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
        :param str id: Ocid for detector recipe
        :param str owner: Owner of detector recipe
        :param str source_detector_recipe_id: Recipe Ocid of the Source Recipe to be cloned
        :param str state: The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        :param Mapping[str, Any] system_tags: System tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). System tags can be viewed by users, but can only be created by the system.  Example: `{"orcl-cloud.free-tier-retained": "true"}`
        :param str time_created: The date and time the detector recipe was created. Format defined by RFC3339.
        :param str time_updated: The date and time the detector recipe was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "defined_tags", defined_tags)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "detector", detector)
        pulumi.set(__self__, "detector_rules", detector_rules)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "effective_detector_rules", effective_detector_rules)
        pulumi.set(__self__, "freeform_tags", freeform_tags)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "owner", owner)
        pulumi.set(__self__, "source_detector_recipe_id", source_detector_recipe_id)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "system_tags", system_tags)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        The ID of the compartment in which to list resources.
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter(name="definedTags")
    def defined_tags(self) -> Mapping[str, Any]:
        """
        Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
        """
        return pulumi.get(self, "defined_tags")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        Description for DetectorRecipeDetectorRule
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def detector(self) -> str:
        """
        detector for the rule
        """
        return pulumi.get(self, "detector")

    @property
    @pulumi.getter(name="detectorRules")
    def detector_rules(self) -> Sequence['outputs.GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleResult']:
        """
        List of detector rules for the detector type for recipe - user input
        """
        return pulumi.get(self, "detector_rules")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        A filter to return only resources that match the entire display name given.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="effectiveDetectorRules")
    def effective_detector_rules(self) -> Sequence['outputs.GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleResult']:
        """
        List of effective detector rules for the detector type for recipe after applying defaults
        """
        return pulumi.get(self, "effective_detector_rules")

    @property
    @pulumi.getter(name="freeformTags")
    def freeform_tags(self) -> Mapping[str, Any]:
        """
        Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
        """
        return pulumi.get(self, "freeform_tags")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Ocid for detector recipe
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def owner(self) -> str:
        """
        Owner of detector recipe
        """
        return pulumi.get(self, "owner")

    @property
    @pulumi.getter(name="sourceDetectorRecipeId")
    def source_detector_recipe_id(self) -> str:
        """
        Recipe Ocid of the Source Recipe to be cloned
        """
        return pulumi.get(self, "source_detector_recipe_id")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="systemTags")
    def system_tags(self) -> Mapping[str, Any]:
        """
        System tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). System tags can be viewed by users, but can only be created by the system.  Example: `{"orcl-cloud.free-tier-retained": "true"}`
        """
        return pulumi.get(self, "system_tags")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the detector recipe was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the detector recipe was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleResult(dict):
    def __init__(__self__, *,
                 candidate_responder_rules: Sequence['outputs.GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleCandidateResponderRuleResult'],
                 description: str,
                 details: 'outputs.GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleDetailsResult',
                 detector: str,
                 detector_rule_id: str,
                 display_name: str,
                 lifecycle_details: str,
                 managed_list_types: Sequence[str],
                 recommendation: str,
                 resource_type: str,
                 service_type: str,
                 state: str,
                 time_created: str,
                 time_updated: str):
        """
        :param Sequence['GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleCandidateResponderRuleArgs'] candidate_responder_rules: List of CandidateResponderRule related to this rule
        :param str description: Description for DetectorRecipeDetectorRule
        :param 'GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleDetailsArgs' details: Details of a Detector Rule
        :param str detector: detector for the rule
        :param str detector_rule_id: The unique identifier of the detector rule
        :param str display_name: A filter to return only resources that match the entire display name given.
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] managed_list_types: List of cloudguard managed list types related to this rule
        :param str recommendation: Recommendation for DetectorRecipeDetectorRule
        :param str resource_type: resource type of the configuration to which the rule is applied
        :param str service_type: service type of the configuration to which the rule is applied
        :param str state: The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        :param str time_created: The date and time the detector recipe was created. Format defined by RFC3339.
        :param str time_updated: The date and time the detector recipe was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "candidate_responder_rules", candidate_responder_rules)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "detector", detector)
        pulumi.set(__self__, "detector_rule_id", detector_rule_id)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        pulumi.set(__self__, "managed_list_types", managed_list_types)
        pulumi.set(__self__, "recommendation", recommendation)
        pulumi.set(__self__, "resource_type", resource_type)
        pulumi.set(__self__, "service_type", service_type)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter(name="candidateResponderRules")
    def candidate_responder_rules(self) -> Sequence['outputs.GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleCandidateResponderRuleResult']:
        """
        List of CandidateResponderRule related to this rule
        """
        return pulumi.get(self, "candidate_responder_rules")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        Description for DetectorRecipeDetectorRule
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def details(self) -> 'outputs.GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleDetailsResult':
        """
        Details of a Detector Rule
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter
    def detector(self) -> str:
        """
        detector for the rule
        """
        return pulumi.get(self, "detector")

    @property
    @pulumi.getter(name="detectorRuleId")
    def detector_rule_id(self) -> str:
        """
        The unique identifier of the detector rule
        """
        return pulumi.get(self, "detector_rule_id")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        A filter to return only resources that match the entire display name given.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter(name="managedListTypes")
    def managed_list_types(self) -> Sequence[str]:
        """
        List of cloudguard managed list types related to this rule
        """
        return pulumi.get(self, "managed_list_types")

    @property
    @pulumi.getter
    def recommendation(self) -> str:
        """
        Recommendation for DetectorRecipeDetectorRule
        """
        return pulumi.get(self, "recommendation")

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> str:
        """
        resource type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "resource_type")

    @property
    @pulumi.getter(name="serviceType")
    def service_type(self) -> str:
        """
        service type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "service_type")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the detector recipe was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the detector recipe was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleCandidateResponderRuleResult(dict):
    def __init__(__self__, *,
                 display_name: str,
                 id: str,
                 is_preferred: bool):
        """
        :param str display_name: A filter to return only resources that match the entire display name given.
        :param str id: Ocid for detector recipe
        :param bool is_preferred: Preferred state
        """
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_preferred", is_preferred)

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        A filter to return only resources that match the entire display name given.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Ocid for detector recipe
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="isPreferred")
    def is_preferred(self) -> bool:
        """
        Preferred state
        """
        return pulumi.get(self, "is_preferred")


@pulumi.output_type
class GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleDetailsResult(dict):
    def __init__(__self__, *,
                 condition: str,
                 configurations: Sequence['outputs.GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleDetailsConfigurationResult'],
                 is_configuration_allowed: bool,
                 is_enabled: bool,
                 labels: Sequence[str],
                 risk_level: str):
        """
        :param Sequence['GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleDetailsConfigurationArgs'] configurations: Configuration details
        :param bool is_configuration_allowed: configuration allowed or not
        :param bool is_enabled: Enables the control
        :param Sequence[str] labels: user defined labels for a detector rule
        :param str risk_level: The Risk Level
        """
        pulumi.set(__self__, "condition", condition)
        pulumi.set(__self__, "configurations", configurations)
        pulumi.set(__self__, "is_configuration_allowed", is_configuration_allowed)
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "risk_level", risk_level)

    @property
    @pulumi.getter
    def condition(self) -> str:
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter
    def configurations(self) -> Sequence['outputs.GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleDetailsConfigurationResult']:
        """
        Configuration details
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isConfigurationAllowed")
    def is_configuration_allowed(self) -> bool:
        """
        configuration allowed or not
        """
        return pulumi.get(self, "is_configuration_allowed")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        """
        Enables the control
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def labels(self) -> Sequence[str]:
        """
        user defined labels for a detector rule
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="riskLevel")
    def risk_level(self) -> str:
        """
        The Risk Level
        """
        return pulumi.get(self, "risk_level")


@pulumi.output_type
class GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleDetailsConfigurationResult(dict):
    def __init__(__self__, *,
                 config_key: str,
                 data_type: str,
                 name: str,
                 value: str,
                 values: Sequence['outputs.GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleDetailsConfigurationValueResult']):
        """
        :param str config_key: Unique name of the configuration
        :param str data_type: configuration data type
        :param str name: configuration name
        :param str value: configuration value
        :param Sequence['GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleDetailsConfigurationValueArgs'] values: List of configuration values
        """
        pulumi.set(__self__, "config_key", config_key)
        pulumi.set(__self__, "data_type", data_type)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> str:
        """
        Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter(name="dataType")
    def data_type(self) -> str:
        """
        configuration data type
        """
        return pulumi.get(self, "data_type")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def values(self) -> Sequence['outputs.GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleDetailsConfigurationValueResult']:
        """
        List of configuration values
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class GetDetectorRecipesDetectorRecipeCollectionItemDetectorRuleDetailsConfigurationValueResult(dict):
    def __init__(__self__, *,
                 list_type: str,
                 managed_list_type: str,
                 value: str):
        """
        :param str list_type: configuration list item type, either CUSTOM or MANAGED
        :param str managed_list_type: type of the managed list
        :param str value: configuration value
        """
        pulumi.set(__self__, "list_type", list_type)
        pulumi.set(__self__, "managed_list_type", managed_list_type)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="listType")
    def list_type(self) -> str:
        """
        configuration list item type, either CUSTOM or MANAGED
        """
        return pulumi.get(self, "list_type")

    @property
    @pulumi.getter(name="managedListType")
    def managed_list_type(self) -> str:
        """
        type of the managed list
        """
        return pulumi.get(self, "managed_list_type")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleResult(dict):
    def __init__(__self__, *,
                 candidate_responder_rules: Sequence['outputs.GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleCandidateResponderRuleResult'],
                 description: str,
                 details: 'outputs.GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleDetailsResult',
                 detector: str,
                 detector_rule_id: str,
                 display_name: str,
                 lifecycle_details: str,
                 managed_list_types: Sequence[str],
                 recommendation: str,
                 resource_type: str,
                 service_type: str,
                 state: str,
                 time_created: str,
                 time_updated: str):
        """
        :param Sequence['GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleCandidateResponderRuleArgs'] candidate_responder_rules: List of CandidateResponderRule related to this rule
        :param str description: Description for DetectorRecipeDetectorRule
        :param 'GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleDetailsArgs' details: Details of a Detector Rule
        :param str detector: detector for the rule
        :param str detector_rule_id: The unique identifier of the detector rule
        :param str display_name: A filter to return only resources that match the entire display name given.
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] managed_list_types: List of cloudguard managed list types related to this rule
        :param str recommendation: Recommendation for DetectorRecipeDetectorRule
        :param str resource_type: resource type of the configuration to which the rule is applied
        :param str service_type: service type of the configuration to which the rule is applied
        :param str state: The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        :param str time_created: The date and time the detector recipe was created. Format defined by RFC3339.
        :param str time_updated: The date and time the detector recipe was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "candidate_responder_rules", candidate_responder_rules)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "detector", detector)
        pulumi.set(__self__, "detector_rule_id", detector_rule_id)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        pulumi.set(__self__, "managed_list_types", managed_list_types)
        pulumi.set(__self__, "recommendation", recommendation)
        pulumi.set(__self__, "resource_type", resource_type)
        pulumi.set(__self__, "service_type", service_type)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter(name="candidateResponderRules")
    def candidate_responder_rules(self) -> Sequence['outputs.GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleCandidateResponderRuleResult']:
        """
        List of CandidateResponderRule related to this rule
        """
        return pulumi.get(self, "candidate_responder_rules")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        Description for DetectorRecipeDetectorRule
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def details(self) -> 'outputs.GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleDetailsResult':
        """
        Details of a Detector Rule
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter
    def detector(self) -> str:
        """
        detector for the rule
        """
        return pulumi.get(self, "detector")

    @property
    @pulumi.getter(name="detectorRuleId")
    def detector_rule_id(self) -> str:
        """
        The unique identifier of the detector rule
        """
        return pulumi.get(self, "detector_rule_id")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        A filter to return only resources that match the entire display name given.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter(name="managedListTypes")
    def managed_list_types(self) -> Sequence[str]:
        """
        List of cloudguard managed list types related to this rule
        """
        return pulumi.get(self, "managed_list_types")

    @property
    @pulumi.getter
    def recommendation(self) -> str:
        """
        Recommendation for DetectorRecipeDetectorRule
        """
        return pulumi.get(self, "recommendation")

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> str:
        """
        resource type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "resource_type")

    @property
    @pulumi.getter(name="serviceType")
    def service_type(self) -> str:
        """
        service type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "service_type")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the detector recipe was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the detector recipe was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleCandidateResponderRuleResult(dict):
    def __init__(__self__, *,
                 display_name: str,
                 id: str,
                 is_preferred: bool):
        """
        :param str display_name: A filter to return only resources that match the entire display name given.
        :param str id: Ocid for detector recipe
        :param bool is_preferred: Preferred state
        """
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_preferred", is_preferred)

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        A filter to return only resources that match the entire display name given.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Ocid for detector recipe
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="isPreferred")
    def is_preferred(self) -> bool:
        """
        Preferred state
        """
        return pulumi.get(self, "is_preferred")


@pulumi.output_type
class GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleDetailsResult(dict):
    def __init__(__self__, *,
                 condition: str,
                 configurations: Sequence['outputs.GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleDetailsConfigurationResult'],
                 is_configuration_allowed: bool,
                 is_enabled: bool,
                 labels: Sequence[str],
                 risk_level: str):
        """
        :param Sequence['GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleDetailsConfigurationArgs'] configurations: Configuration details
        :param bool is_configuration_allowed: configuration allowed or not
        :param bool is_enabled: Enables the control
        :param Sequence[str] labels: user defined labels for a detector rule
        :param str risk_level: The Risk Level
        """
        pulumi.set(__self__, "condition", condition)
        pulumi.set(__self__, "configurations", configurations)
        pulumi.set(__self__, "is_configuration_allowed", is_configuration_allowed)
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "risk_level", risk_level)

    @property
    @pulumi.getter
    def condition(self) -> str:
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter
    def configurations(self) -> Sequence['outputs.GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleDetailsConfigurationResult']:
        """
        Configuration details
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isConfigurationAllowed")
    def is_configuration_allowed(self) -> bool:
        """
        configuration allowed or not
        """
        return pulumi.get(self, "is_configuration_allowed")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        """
        Enables the control
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def labels(self) -> Sequence[str]:
        """
        user defined labels for a detector rule
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="riskLevel")
    def risk_level(self) -> str:
        """
        The Risk Level
        """
        return pulumi.get(self, "risk_level")


@pulumi.output_type
class GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleDetailsConfigurationResult(dict):
    def __init__(__self__, *,
                 config_key: str,
                 data_type: str,
                 name: str,
                 value: str,
                 values: Sequence['outputs.GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleDetailsConfigurationValueResult']):
        """
        :param str config_key: Unique name of the configuration
        :param str data_type: configuration data type
        :param str name: configuration name
        :param str value: configuration value
        :param Sequence['GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleDetailsConfigurationValueArgs'] values: List of configuration values
        """
        pulumi.set(__self__, "config_key", config_key)
        pulumi.set(__self__, "data_type", data_type)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> str:
        """
        Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter(name="dataType")
    def data_type(self) -> str:
        """
        configuration data type
        """
        return pulumi.get(self, "data_type")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def values(self) -> Sequence['outputs.GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleDetailsConfigurationValueResult']:
        """
        List of configuration values
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class GetDetectorRecipesDetectorRecipeCollectionItemEffectiveDetectorRuleDetailsConfigurationValueResult(dict):
    def __init__(__self__, *,
                 list_type: str,
                 managed_list_type: str,
                 value: str):
        """
        :param str list_type: configuration list item type, either CUSTOM or MANAGED
        :param str managed_list_type: type of the managed list
        :param str value: configuration value
        """
        pulumi.set(__self__, "list_type", list_type)
        pulumi.set(__self__, "managed_list_type", managed_list_type)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="listType")
    def list_type(self) -> str:
        """
        configuration list item type, either CUSTOM or MANAGED
        """
        return pulumi.get(self, "list_type")

    @property
    @pulumi.getter(name="managedListType")
    def managed_list_type(self) -> str:
        """
        type of the managed list
        """
        return pulumi.get(self, "managed_list_type")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetDetectorRecipesFilterResult(dict):
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str],
                 regex: Optional[bool] = None):
        """
        :param str name: configuration name
        :param Sequence[str] values: List of configuration values
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)
        if regex is not None:
            pulumi.set(__self__, "regex", regex)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        List of configuration values
        """
        return pulumi.get(self, "values")

    @property
    @pulumi.getter
    def regex(self) -> Optional[bool]:
        return pulumi.get(self, "regex")


@pulumi.output_type
class GetManagedListsFilterResult(dict):
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str],
                 regex: Optional[bool] = None):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)
        if regex is not None:
            pulumi.set(__self__, "regex", regex)

    @property
    @pulumi.getter
    def name(self) -> str:
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        return pulumi.get(self, "values")

    @property
    @pulumi.getter
    def regex(self) -> Optional[bool]:
        return pulumi.get(self, "regex")


@pulumi.output_type
class GetManagedListsManagedListCollectionResult(dict):
    def __init__(__self__, *,
                 items: Sequence['outputs.GetManagedListsManagedListCollectionItemResult']):
        pulumi.set(__self__, "items", items)

    @property
    @pulumi.getter
    def items(self) -> Sequence['outputs.GetManagedListsManagedListCollectionItemResult']:
        return pulumi.get(self, "items")


@pulumi.output_type
class GetManagedListsManagedListCollectionItemResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 defined_tags: Mapping[str, Any],
                 description: str,
                 display_name: str,
                 feed_provider: str,
                 freeform_tags: Mapping[str, Any],
                 id: str,
                 is_editable: bool,
                 lifecyle_details: str,
                 list_items: Sequence[str],
                 list_type: str,
                 source_managed_list_id: str,
                 state: str,
                 system_tags: Mapping[str, Any],
                 time_created: str,
                 time_updated: str):
        """
        :param str compartment_id: The ID of the compartment in which to list resources.
        :param Mapping[str, Any] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
        :param str description: ManagedList description
        :param str display_name: A filter to return only resources that match the entire display name given.
        :param str feed_provider: provider of the feed
        :param Mapping[str, Any] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
        :param str id: Unique identifier that is immutable on creation
        :param bool is_editable: If this list is editable or not
        :param str lifecyle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] list_items: List of ManagedListItem
        :param str list_type: The type of the ManagedList.
        :param str source_managed_list_id: OCID of the Source ManagedList
        :param str state: The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        :param Mapping[str, Any] system_tags: System tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). System tags can be viewed by users, but can only be created by the system.  Example: `{"orcl-cloud.free-tier-retained": "true"}`
        :param str time_created: The date and time the managed list was created. Format defined by RFC3339.
        :param str time_updated: The date and time the managed list was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "defined_tags", defined_tags)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "feed_provider", feed_provider)
        pulumi.set(__self__, "freeform_tags", freeform_tags)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_editable", is_editable)
        pulumi.set(__self__, "lifecyle_details", lifecyle_details)
        pulumi.set(__self__, "list_items", list_items)
        pulumi.set(__self__, "list_type", list_type)
        pulumi.set(__self__, "source_managed_list_id", source_managed_list_id)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "system_tags", system_tags)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        The ID of the compartment in which to list resources.
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter(name="definedTags")
    def defined_tags(self) -> Mapping[str, Any]:
        """
        Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
        """
        return pulumi.get(self, "defined_tags")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        ManagedList description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        A filter to return only resources that match the entire display name given.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="feedProvider")
    def feed_provider(self) -> str:
        """
        provider of the feed
        """
        return pulumi.get(self, "feed_provider")

    @property
    @pulumi.getter(name="freeformTags")
    def freeform_tags(self) -> Mapping[str, Any]:
        """
        Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
        """
        return pulumi.get(self, "freeform_tags")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Unique identifier that is immutable on creation
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="isEditable")
    def is_editable(self) -> bool:
        """
        If this list is editable or not
        """
        return pulumi.get(self, "is_editable")

    @property
    @pulumi.getter(name="lifecyleDetails")
    def lifecyle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecyle_details")

    @property
    @pulumi.getter(name="listItems")
    def list_items(self) -> Sequence[str]:
        """
        List of ManagedListItem
        """
        return pulumi.get(self, "list_items")

    @property
    @pulumi.getter(name="listType")
    def list_type(self) -> str:
        """
        The type of the ManagedList.
        """
        return pulumi.get(self, "list_type")

    @property
    @pulumi.getter(name="sourceManagedListId")
    def source_managed_list_id(self) -> str:
        """
        OCID of the Source ManagedList
        """
        return pulumi.get(self, "source_managed_list_id")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="systemTags")
    def system_tags(self) -> Mapping[str, Any]:
        """
        System tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). System tags can be viewed by users, but can only be created by the system.  Example: `{"orcl-cloud.free-tier-retained": "true"}`
        """
        return pulumi.get(self, "system_tags")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the managed list was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the managed list was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class GetResponderRecipeEffectiveResponderRuleResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 description: str,
                 details: 'outputs.GetResponderRecipeEffectiveResponderRuleDetailsResult',
                 display_name: str,
                 lifecycle_details: str,
                 policies: Sequence[str],
                 responder_rule_id: str,
                 state: str,
                 supported_modes: Sequence[str],
                 time_created: str,
                 time_updated: str,
                 type: str):
        """
        :param str compartment_id: Compartment Identifier
        :param str description: ResponderRule Description
        :param 'GetResponderRecipeEffectiveResponderRuleDetailsArgs' details: Details of ResponderRule.
        :param str display_name: ResponderRule Display Name
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] policies: List of Policy
        :param str responder_rule_id: Identifier for ResponderRule.
        :param str state: The current state of the Example.
        :param Sequence[str] supported_modes: Supported Execution Modes
        :param str time_created: The date and time the responder recipe was created. Format defined by RFC3339.
        :param str time_updated: The date and time the responder recipe was updated. Format defined by RFC3339.
        :param str type: Type of Responder
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        pulumi.set(__self__, "policies", policies)
        pulumi.set(__self__, "responder_rule_id", responder_rule_id)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "supported_modes", supported_modes)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        Compartment Identifier
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        ResponderRule Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def details(self) -> 'outputs.GetResponderRecipeEffectiveResponderRuleDetailsResult':
        """
        Details of ResponderRule.
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        ResponderRule Display Name
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter
    def policies(self) -> Sequence[str]:
        """
        List of Policy
        """
        return pulumi.get(self, "policies")

    @property
    @pulumi.getter(name="responderRuleId")
    def responder_rule_id(self) -> str:
        """
        Identifier for ResponderRule.
        """
        return pulumi.get(self, "responder_rule_id")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The current state of the Example.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="supportedModes")
    def supported_modes(self) -> Sequence[str]:
        """
        Supported Execution Modes
        """
        return pulumi.get(self, "supported_modes")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the responder recipe was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the responder recipe was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Type of Responder
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetResponderRecipeEffectiveResponderRuleDetailsResult(dict):
    def __init__(__self__, *,
                 condition: str,
                 configurations: Sequence['outputs.GetResponderRecipeEffectiveResponderRuleDetailsConfigurationResult'],
                 is_enabled: bool,
                 mode: str):
        """
        :param Sequence['GetResponderRecipeEffectiveResponderRuleDetailsConfigurationArgs'] configurations: ResponderRule configurations
        :param bool is_enabled: Identifies state for ResponderRule
        :param str mode: Execution Mode for ResponderRule
        """
        pulumi.set(__self__, "condition", condition)
        pulumi.set(__self__, "configurations", configurations)
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def condition(self) -> str:
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter
    def configurations(self) -> Sequence['outputs.GetResponderRecipeEffectiveResponderRuleDetailsConfigurationResult']:
        """
        ResponderRule configurations
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        """
        Identifies state for ResponderRule
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        Execution Mode for ResponderRule
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class GetResponderRecipeEffectiveResponderRuleDetailsConfigurationResult(dict):
    def __init__(__self__, *,
                 config_key: str,
                 name: str,
                 value: str):
        """
        :param str config_key: Unique name of the configuration
        :param str name: configuration name
        :param str value: configuration value
        """
        pulumi.set(__self__, "config_key", config_key)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> str:
        """
        Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetResponderRecipeResponderRuleResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 description: str,
                 details: 'outputs.GetResponderRecipeResponderRuleDetailsResult',
                 display_name: str,
                 lifecycle_details: str,
                 policies: Sequence[str],
                 responder_rule_id: str,
                 state: str,
                 supported_modes: Sequence[str],
                 time_created: str,
                 time_updated: str,
                 type: str):
        """
        :param str compartment_id: Compartment Identifier
        :param str description: ResponderRule Description
        :param 'GetResponderRecipeResponderRuleDetailsArgs' details: Details of ResponderRule.
        :param str display_name: ResponderRule Display Name
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] policies: List of Policy
        :param str responder_rule_id: Identifier for ResponderRule.
        :param str state: The current state of the Example.
        :param Sequence[str] supported_modes: Supported Execution Modes
        :param str time_created: The date and time the responder recipe was created. Format defined by RFC3339.
        :param str time_updated: The date and time the responder recipe was updated. Format defined by RFC3339.
        :param str type: Type of Responder
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        pulumi.set(__self__, "policies", policies)
        pulumi.set(__self__, "responder_rule_id", responder_rule_id)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "supported_modes", supported_modes)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        Compartment Identifier
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        ResponderRule Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def details(self) -> 'outputs.GetResponderRecipeResponderRuleDetailsResult':
        """
        Details of ResponderRule.
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        ResponderRule Display Name
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter
    def policies(self) -> Sequence[str]:
        """
        List of Policy
        """
        return pulumi.get(self, "policies")

    @property
    @pulumi.getter(name="responderRuleId")
    def responder_rule_id(self) -> str:
        """
        Identifier for ResponderRule.
        """
        return pulumi.get(self, "responder_rule_id")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The current state of the Example.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="supportedModes")
    def supported_modes(self) -> Sequence[str]:
        """
        Supported Execution Modes
        """
        return pulumi.get(self, "supported_modes")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the responder recipe was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the responder recipe was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Type of Responder
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetResponderRecipeResponderRuleDetailsResult(dict):
    def __init__(__self__, *,
                 condition: str,
                 configurations: Sequence['outputs.GetResponderRecipeResponderRuleDetailsConfigurationResult'],
                 is_enabled: bool,
                 mode: str):
        """
        :param Sequence['GetResponderRecipeResponderRuleDetailsConfigurationArgs'] configurations: ResponderRule configurations
        :param bool is_enabled: Identifies state for ResponderRule
        :param str mode: Execution Mode for ResponderRule
        """
        pulumi.set(__self__, "condition", condition)
        pulumi.set(__self__, "configurations", configurations)
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def condition(self) -> str:
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter
    def configurations(self) -> Sequence['outputs.GetResponderRecipeResponderRuleDetailsConfigurationResult']:
        """
        ResponderRule configurations
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        """
        Identifies state for ResponderRule
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        Execution Mode for ResponderRule
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class GetResponderRecipeResponderRuleDetailsConfigurationResult(dict):
    def __init__(__self__, *,
                 config_key: str,
                 name: str,
                 value: str):
        """
        :param str config_key: Unique name of the configuration
        :param str name: configuration name
        :param str value: configuration value
        """
        pulumi.set(__self__, "config_key", config_key)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> str:
        """
        Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetResponderRecipesFilterResult(dict):
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str],
                 regex: Optional[bool] = None):
        """
        :param str name: configuration name
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)
        if regex is not None:
            pulumi.set(__self__, "regex", regex)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        return pulumi.get(self, "values")

    @property
    @pulumi.getter
    def regex(self) -> Optional[bool]:
        return pulumi.get(self, "regex")


@pulumi.output_type
class GetResponderRecipesResponderRecipeCollectionResult(dict):
    def __init__(__self__, *,
                 items: Sequence['outputs.GetResponderRecipesResponderRecipeCollectionItemResult']):
        pulumi.set(__self__, "items", items)

    @property
    @pulumi.getter
    def items(self) -> Sequence['outputs.GetResponderRecipesResponderRecipeCollectionItemResult']:
        return pulumi.get(self, "items")


@pulumi.output_type
class GetResponderRecipesResponderRecipeCollectionItemResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 defined_tags: Mapping[str, Any],
                 description: str,
                 display_name: str,
                 effective_responder_rules: Sequence['outputs.GetResponderRecipesResponderRecipeCollectionItemEffectiveResponderRuleResult'],
                 freeform_tags: Mapping[str, Any],
                 id: str,
                 lifecycle_details: str,
                 owner: str,
                 responder_rules: Sequence['outputs.GetResponderRecipesResponderRecipeCollectionItemResponderRuleResult'],
                 source_responder_recipe_id: str,
                 state: str,
                 system_tags: Mapping[str, Any],
                 time_created: str,
                 time_updated: str):
        """
        :param str compartment_id: The ID of the compartment in which to list resources.
        :param Mapping[str, Any] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
        :param str description: ResponderRule Description
        :param str display_name: A filter to return only resources that match the entire display name given.
        :param Sequence['GetResponderRecipesResponderRecipeCollectionItemEffectiveResponderRuleArgs'] effective_responder_rules: List of responder rules associated with the recipe
        :param Mapping[str, Any] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
        :param str id: Identifier for ResponderRecipe.
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param str owner: Owner of ResponderRecipe
        :param Sequence['GetResponderRecipesResponderRecipeCollectionItemResponderRuleArgs'] responder_rules: List of responder rules associated with the recipe
        :param str source_responder_recipe_id: The id of the source responder recipe.
        :param str state: The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        :param Mapping[str, Any] system_tags: System tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). System tags can be viewed by users, but can only be created by the system.  Example: `{"orcl-cloud.free-tier-retained": "true"}`
        :param str time_created: The date and time the responder recipe was created. Format defined by RFC3339.
        :param str time_updated: The date and time the responder recipe was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "defined_tags", defined_tags)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "effective_responder_rules", effective_responder_rules)
        pulumi.set(__self__, "freeform_tags", freeform_tags)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        pulumi.set(__self__, "owner", owner)
        pulumi.set(__self__, "responder_rules", responder_rules)
        pulumi.set(__self__, "source_responder_recipe_id", source_responder_recipe_id)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "system_tags", system_tags)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        The ID of the compartment in which to list resources.
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter(name="definedTags")
    def defined_tags(self) -> Mapping[str, Any]:
        """
        Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
        """
        return pulumi.get(self, "defined_tags")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        ResponderRule Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        A filter to return only resources that match the entire display name given.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="effectiveResponderRules")
    def effective_responder_rules(self) -> Sequence['outputs.GetResponderRecipesResponderRecipeCollectionItemEffectiveResponderRuleResult']:
        """
        List of responder rules associated with the recipe
        """
        return pulumi.get(self, "effective_responder_rules")

    @property
    @pulumi.getter(name="freeformTags")
    def freeform_tags(self) -> Mapping[str, Any]:
        """
        Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
        """
        return pulumi.get(self, "freeform_tags")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Identifier for ResponderRecipe.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter
    def owner(self) -> str:
        """
        Owner of ResponderRecipe
        """
        return pulumi.get(self, "owner")

    @property
    @pulumi.getter(name="responderRules")
    def responder_rules(self) -> Sequence['outputs.GetResponderRecipesResponderRecipeCollectionItemResponderRuleResult']:
        """
        List of responder rules associated with the recipe
        """
        return pulumi.get(self, "responder_rules")

    @property
    @pulumi.getter(name="sourceResponderRecipeId")
    def source_responder_recipe_id(self) -> str:
        """
        The id of the source responder recipe.
        """
        return pulumi.get(self, "source_responder_recipe_id")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="systemTags")
    def system_tags(self) -> Mapping[str, Any]:
        """
        System tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). System tags can be viewed by users, but can only be created by the system.  Example: `{"orcl-cloud.free-tier-retained": "true"}`
        """
        return pulumi.get(self, "system_tags")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the responder recipe was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the responder recipe was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class GetResponderRecipesResponderRecipeCollectionItemEffectiveResponderRuleResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 description: str,
                 details: 'outputs.GetResponderRecipesResponderRecipeCollectionItemEffectiveResponderRuleDetailsResult',
                 display_name: str,
                 lifecycle_details: str,
                 policies: Sequence[str],
                 responder_rule_id: str,
                 state: str,
                 supported_modes: Sequence[str],
                 time_created: str,
                 time_updated: str,
                 type: str):
        """
        :param str compartment_id: The ID of the compartment in which to list resources.
        :param str description: ResponderRule Description
        :param 'GetResponderRecipesResponderRecipeCollectionItemEffectiveResponderRuleDetailsArgs' details: Details of ResponderRule.
        :param str display_name: A filter to return only resources that match the entire display name given.
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] policies: List of Policy
        :param str responder_rule_id: Identifier for ResponderRule.
        :param str state: The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        :param Sequence[str] supported_modes: Supported Execution Modes
        :param str time_created: The date and time the responder recipe was created. Format defined by RFC3339.
        :param str time_updated: The date and time the responder recipe was updated. Format defined by RFC3339.
        :param str type: Type of Responder
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        pulumi.set(__self__, "policies", policies)
        pulumi.set(__self__, "responder_rule_id", responder_rule_id)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "supported_modes", supported_modes)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        The ID of the compartment in which to list resources.
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        ResponderRule Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def details(self) -> 'outputs.GetResponderRecipesResponderRecipeCollectionItemEffectiveResponderRuleDetailsResult':
        """
        Details of ResponderRule.
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        A filter to return only resources that match the entire display name given.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter
    def policies(self) -> Sequence[str]:
        """
        List of Policy
        """
        return pulumi.get(self, "policies")

    @property
    @pulumi.getter(name="responderRuleId")
    def responder_rule_id(self) -> str:
        """
        Identifier for ResponderRule.
        """
        return pulumi.get(self, "responder_rule_id")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="supportedModes")
    def supported_modes(self) -> Sequence[str]:
        """
        Supported Execution Modes
        """
        return pulumi.get(self, "supported_modes")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the responder recipe was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the responder recipe was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Type of Responder
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetResponderRecipesResponderRecipeCollectionItemEffectiveResponderRuleDetailsResult(dict):
    def __init__(__self__, *,
                 condition: str,
                 configurations: Sequence['outputs.GetResponderRecipesResponderRecipeCollectionItemEffectiveResponderRuleDetailsConfigurationResult'],
                 is_enabled: bool,
                 mode: str):
        """
        :param Sequence['GetResponderRecipesResponderRecipeCollectionItemEffectiveResponderRuleDetailsConfigurationArgs'] configurations: ResponderRule configurations
        :param bool is_enabled: Identifies state for ResponderRule
        :param str mode: Execution Mode for ResponderRule
        """
        pulumi.set(__self__, "condition", condition)
        pulumi.set(__self__, "configurations", configurations)
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def condition(self) -> str:
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter
    def configurations(self) -> Sequence['outputs.GetResponderRecipesResponderRecipeCollectionItemEffectiveResponderRuleDetailsConfigurationResult']:
        """
        ResponderRule configurations
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        """
        Identifies state for ResponderRule
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        Execution Mode for ResponderRule
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class GetResponderRecipesResponderRecipeCollectionItemEffectiveResponderRuleDetailsConfigurationResult(dict):
    def __init__(__self__, *,
                 config_key: str,
                 name: str,
                 value: str):
        """
        :param str config_key: Unique name of the configuration
        :param str name: configuration name
        :param str value: configuration value
        """
        pulumi.set(__self__, "config_key", config_key)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> str:
        """
        Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetResponderRecipesResponderRecipeCollectionItemResponderRuleResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 description: str,
                 details: 'outputs.GetResponderRecipesResponderRecipeCollectionItemResponderRuleDetailsResult',
                 display_name: str,
                 lifecycle_details: str,
                 policies: Sequence[str],
                 responder_rule_id: str,
                 state: str,
                 supported_modes: Sequence[str],
                 time_created: str,
                 time_updated: str,
                 type: str):
        """
        :param str compartment_id: The ID of the compartment in which to list resources.
        :param str description: ResponderRule Description
        :param 'GetResponderRecipesResponderRecipeCollectionItemResponderRuleDetailsArgs' details: Details of ResponderRule.
        :param str display_name: A filter to return only resources that match the entire display name given.
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] policies: List of Policy
        :param str responder_rule_id: Identifier for ResponderRule.
        :param str state: The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        :param Sequence[str] supported_modes: Supported Execution Modes
        :param str time_created: The date and time the responder recipe was created. Format defined by RFC3339.
        :param str time_updated: The date and time the responder recipe was updated. Format defined by RFC3339.
        :param str type: Type of Responder
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        pulumi.set(__self__, "policies", policies)
        pulumi.set(__self__, "responder_rule_id", responder_rule_id)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "supported_modes", supported_modes)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        The ID of the compartment in which to list resources.
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        ResponderRule Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def details(self) -> 'outputs.GetResponderRecipesResponderRecipeCollectionItemResponderRuleDetailsResult':
        """
        Details of ResponderRule.
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        A filter to return only resources that match the entire display name given.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter
    def policies(self) -> Sequence[str]:
        """
        List of Policy
        """
        return pulumi.get(self, "policies")

    @property
    @pulumi.getter(name="responderRuleId")
    def responder_rule_id(self) -> str:
        """
        Identifier for ResponderRule.
        """
        return pulumi.get(self, "responder_rule_id")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="supportedModes")
    def supported_modes(self) -> Sequence[str]:
        """
        Supported Execution Modes
        """
        return pulumi.get(self, "supported_modes")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the responder recipe was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the responder recipe was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Type of Responder
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetResponderRecipesResponderRecipeCollectionItemResponderRuleDetailsResult(dict):
    def __init__(__self__, *,
                 condition: str,
                 configurations: Sequence['outputs.GetResponderRecipesResponderRecipeCollectionItemResponderRuleDetailsConfigurationResult'],
                 is_enabled: bool,
                 mode: str):
        """
        :param Sequence['GetResponderRecipesResponderRecipeCollectionItemResponderRuleDetailsConfigurationArgs'] configurations: ResponderRule configurations
        :param bool is_enabled: Identifies state for ResponderRule
        :param str mode: Execution Mode for ResponderRule
        """
        pulumi.set(__self__, "condition", condition)
        pulumi.set(__self__, "configurations", configurations)
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def condition(self) -> str:
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter
    def configurations(self) -> Sequence['outputs.GetResponderRecipesResponderRecipeCollectionItemResponderRuleDetailsConfigurationResult']:
        """
        ResponderRule configurations
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        """
        Identifies state for ResponderRule
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        Execution Mode for ResponderRule
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class GetResponderRecipesResponderRecipeCollectionItemResponderRuleDetailsConfigurationResult(dict):
    def __init__(__self__, *,
                 config_key: str,
                 name: str,
                 value: str):
        """
        :param str config_key: Unique name of the configuration
        :param str name: configuration name
        :param str value: configuration value
        """
        pulumi.set(__self__, "config_key", config_key)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> str:
        """
        Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetTargetTargetDetectorRecipeResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 description: str,
                 detector: str,
                 detector_recipe_id: str,
                 detector_rules: Sequence['outputs.GetTargetTargetDetectorRecipeDetectorRuleResult'],
                 display_name: str,
                 effective_detector_rules: Sequence['outputs.GetTargetTargetDetectorRecipeEffectiveDetectorRuleResult'],
                 id: str,
                 owner: str,
                 state: str,
                 time_created: str,
                 time_updated: str):
        """
        :param str compartment_id: Compartment Identifier
        :param str description: ResponderRule Description
        :param str detector: detector for the rule
        :param str detector_recipe_id: Unique identifier for Detector Recipe of which this is an extension
        :param Sequence['GetTargetTargetDetectorRecipeDetectorRuleArgs'] detector_rules: List of detector rules for the detector type for recipe - user input
        :param str display_name: ResponderRule Display Name
        :param Sequence['GetTargetTargetDetectorRecipeEffectiveDetectorRuleArgs'] effective_detector_rules: List of effective detector rules for the detector type for recipe after applying defaults
        :param str id: Unique identifier of TargetResponderRecipe that is immutable on creation
        :param str owner: Owner of ResponderRecipe
        :param str state: The current state of the ResponderRule.
        :param str time_created: The date and time the target was created. Format defined by RFC3339.
        :param str time_updated: The date and time the target was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "detector", detector)
        pulumi.set(__self__, "detector_recipe_id", detector_recipe_id)
        pulumi.set(__self__, "detector_rules", detector_rules)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "effective_detector_rules", effective_detector_rules)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "owner", owner)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        Compartment Identifier
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        ResponderRule Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def detector(self) -> str:
        """
        detector for the rule
        """
        return pulumi.get(self, "detector")

    @property
    @pulumi.getter(name="detectorRecipeId")
    def detector_recipe_id(self) -> str:
        """
        Unique identifier for Detector Recipe of which this is an extension
        """
        return pulumi.get(self, "detector_recipe_id")

    @property
    @pulumi.getter(name="detectorRules")
    def detector_rules(self) -> Sequence['outputs.GetTargetTargetDetectorRecipeDetectorRuleResult']:
        """
        List of detector rules for the detector type for recipe - user input
        """
        return pulumi.get(self, "detector_rules")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        ResponderRule Display Name
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="effectiveDetectorRules")
    def effective_detector_rules(self) -> Sequence['outputs.GetTargetTargetDetectorRecipeEffectiveDetectorRuleResult']:
        """
        List of effective detector rules for the detector type for recipe after applying defaults
        """
        return pulumi.get(self, "effective_detector_rules")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Unique identifier of TargetResponderRecipe that is immutable on creation
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def owner(self) -> str:
        """
        Owner of ResponderRecipe
        """
        return pulumi.get(self, "owner")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The current state of the ResponderRule.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the target was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the target was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class GetTargetTargetDetectorRecipeDetectorRuleResult(dict):
    def __init__(__self__, *,
                 description: str,
                 details: 'outputs.GetTargetTargetDetectorRecipeDetectorRuleDetailsResult',
                 detector: str,
                 detector_rule_id: str,
                 display_name: str,
                 lifecycle_details: str,
                 managed_list_types: Sequence[str],
                 recommendation: str,
                 resource_type: str,
                 service_type: str,
                 state: str,
                 time_created: str,
                 time_updated: str):
        """
        :param str description: ResponderRule Description
        :param 'GetTargetTargetDetectorRecipeDetectorRuleDetailsArgs' details: Details of ResponderRule.
        :param str detector: detector for the rule
        :param str detector_rule_id: The unique identifier of the detector rule
        :param str display_name: ResponderRule Display Name
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] managed_list_types: List of cloudguard managed list types related to this rule
        :param str recommendation: Recommendation for TargetDetectorRecipeDetectorRule
        :param str resource_type: resource type of the configuration to which the rule is applied
        :param str service_type: service type of the configuration to which the rule is applied
        :param str state: The current state of the ResponderRule.
        :param str time_created: The date and time the target was created. Format defined by RFC3339.
        :param str time_updated: The date and time the target was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "detector", detector)
        pulumi.set(__self__, "detector_rule_id", detector_rule_id)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        pulumi.set(__self__, "managed_list_types", managed_list_types)
        pulumi.set(__self__, "recommendation", recommendation)
        pulumi.set(__self__, "resource_type", resource_type)
        pulumi.set(__self__, "service_type", service_type)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        ResponderRule Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def details(self) -> 'outputs.GetTargetTargetDetectorRecipeDetectorRuleDetailsResult':
        """
        Details of ResponderRule.
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter
    def detector(self) -> str:
        """
        detector for the rule
        """
        return pulumi.get(self, "detector")

    @property
    @pulumi.getter(name="detectorRuleId")
    def detector_rule_id(self) -> str:
        """
        The unique identifier of the detector rule
        """
        return pulumi.get(self, "detector_rule_id")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        ResponderRule Display Name
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter(name="managedListTypes")
    def managed_list_types(self) -> Sequence[str]:
        """
        List of cloudguard managed list types related to this rule
        """
        return pulumi.get(self, "managed_list_types")

    @property
    @pulumi.getter
    def recommendation(self) -> str:
        """
        Recommendation for TargetDetectorRecipeDetectorRule
        """
        return pulumi.get(self, "recommendation")

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> str:
        """
        resource type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "resource_type")

    @property
    @pulumi.getter(name="serviceType")
    def service_type(self) -> str:
        """
        service type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "service_type")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The current state of the ResponderRule.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the target was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the target was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class GetTargetTargetDetectorRecipeDetectorRuleDetailsResult(dict):
    def __init__(__self__, *,
                 condition_groups: Sequence['outputs.GetTargetTargetDetectorRecipeDetectorRuleDetailsConditionGroupResult'],
                 configurations: Sequence['outputs.GetTargetTargetDetectorRecipeDetectorRuleDetailsConfigurationResult'],
                 is_configuration_allowed: bool,
                 is_enabled: bool,
                 labels: Sequence[str],
                 risk_level: str):
        """
        :param Sequence['GetTargetTargetDetectorRecipeDetectorRuleDetailsConditionGroupArgs'] condition_groups: Condition group corresponding to each compartment
        :param Sequence['GetTargetTargetDetectorRecipeDetectorRuleDetailsConfigurationArgs'] configurations: ResponderRule configurations
        :param bool is_configuration_allowed: configuration allowed or not
        :param bool is_enabled: Identifies state for ResponderRule
        :param Sequence[str] labels: user defined labels for a detector rule
        :param str risk_level: The Risk Level
        """
        pulumi.set(__self__, "condition_groups", condition_groups)
        pulumi.set(__self__, "configurations", configurations)
        pulumi.set(__self__, "is_configuration_allowed", is_configuration_allowed)
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "risk_level", risk_level)

    @property
    @pulumi.getter(name="conditionGroups")
    def condition_groups(self) -> Sequence['outputs.GetTargetTargetDetectorRecipeDetectorRuleDetailsConditionGroupResult']:
        """
        Condition group corresponding to each compartment
        """
        return pulumi.get(self, "condition_groups")

    @property
    @pulumi.getter
    def configurations(self) -> Sequence['outputs.GetTargetTargetDetectorRecipeDetectorRuleDetailsConfigurationResult']:
        """
        ResponderRule configurations
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isConfigurationAllowed")
    def is_configuration_allowed(self) -> bool:
        """
        configuration allowed or not
        """
        return pulumi.get(self, "is_configuration_allowed")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        """
        Identifies state for ResponderRule
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def labels(self) -> Sequence[str]:
        """
        user defined labels for a detector rule
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="riskLevel")
    def risk_level(self) -> str:
        """
        The Risk Level
        """
        return pulumi.get(self, "risk_level")


@pulumi.output_type
class GetTargetTargetDetectorRecipeDetectorRuleDetailsConditionGroupResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 condition: str):
        """
        :param str compartment_id: Compartment Identifier
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "condition", condition)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        Compartment Identifier
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def condition(self) -> str:
        return pulumi.get(self, "condition")


@pulumi.output_type
class GetTargetTargetDetectorRecipeDetectorRuleDetailsConfigurationResult(dict):
    def __init__(__self__, *,
                 config_key: str,
                 data_type: str,
                 name: str,
                 value: str,
                 values: Sequence['outputs.GetTargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueResult']):
        """
        :param str config_key: Unique name of the configuration
        :param str data_type: configuration data type
        :param str name: configuration name
        :param str value: configuration value
        :param Sequence['GetTargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueArgs'] values: List of configuration values
        """
        pulumi.set(__self__, "config_key", config_key)
        pulumi.set(__self__, "data_type", data_type)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> str:
        """
        Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter(name="dataType")
    def data_type(self) -> str:
        """
        configuration data type
        """
        return pulumi.get(self, "data_type")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def values(self) -> Sequence['outputs.GetTargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueResult']:
        """
        List of configuration values
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class GetTargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueResult(dict):
    def __init__(__self__, *,
                 list_type: str,
                 managed_list_type: str,
                 value: str):
        """
        :param str list_type: configuration list item type, either CUSTOM or MANAGED
        :param str managed_list_type: type of the managed list
        :param str value: configuration value
        """
        pulumi.set(__self__, "list_type", list_type)
        pulumi.set(__self__, "managed_list_type", managed_list_type)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="listType")
    def list_type(self) -> str:
        """
        configuration list item type, either CUSTOM or MANAGED
        """
        return pulumi.get(self, "list_type")

    @property
    @pulumi.getter(name="managedListType")
    def managed_list_type(self) -> str:
        """
        type of the managed list
        """
        return pulumi.get(self, "managed_list_type")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetTargetTargetDetectorRecipeEffectiveDetectorRuleResult(dict):
    def __init__(__self__, *,
                 description: str,
                 details: 'outputs.GetTargetTargetDetectorRecipeEffectiveDetectorRuleDetailsResult',
                 detector: str,
                 detector_rule_id: str,
                 display_name: str,
                 lifecycle_details: str,
                 managed_list_types: Sequence[str],
                 recommendation: str,
                 resource_type: str,
                 service_type: str,
                 state: str,
                 time_created: str,
                 time_updated: str):
        """
        :param str description: ResponderRule Description
        :param 'GetTargetTargetDetectorRecipeEffectiveDetectorRuleDetailsArgs' details: Details of ResponderRule.
        :param str detector: detector for the rule
        :param str detector_rule_id: The unique identifier of the detector rule
        :param str display_name: ResponderRule Display Name
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] managed_list_types: List of cloudguard managed list types related to this rule
        :param str recommendation: Recommendation for TargetDetectorRecipeDetectorRule
        :param str resource_type: resource type of the configuration to which the rule is applied
        :param str service_type: service type of the configuration to which the rule is applied
        :param str state: The current state of the ResponderRule.
        :param str time_created: The date and time the target was created. Format defined by RFC3339.
        :param str time_updated: The date and time the target was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "detector", detector)
        pulumi.set(__self__, "detector_rule_id", detector_rule_id)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        pulumi.set(__self__, "managed_list_types", managed_list_types)
        pulumi.set(__self__, "recommendation", recommendation)
        pulumi.set(__self__, "resource_type", resource_type)
        pulumi.set(__self__, "service_type", service_type)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        ResponderRule Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def details(self) -> 'outputs.GetTargetTargetDetectorRecipeEffectiveDetectorRuleDetailsResult':
        """
        Details of ResponderRule.
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter
    def detector(self) -> str:
        """
        detector for the rule
        """
        return pulumi.get(self, "detector")

    @property
    @pulumi.getter(name="detectorRuleId")
    def detector_rule_id(self) -> str:
        """
        The unique identifier of the detector rule
        """
        return pulumi.get(self, "detector_rule_id")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        ResponderRule Display Name
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter(name="managedListTypes")
    def managed_list_types(self) -> Sequence[str]:
        """
        List of cloudguard managed list types related to this rule
        """
        return pulumi.get(self, "managed_list_types")

    @property
    @pulumi.getter
    def recommendation(self) -> str:
        """
        Recommendation for TargetDetectorRecipeDetectorRule
        """
        return pulumi.get(self, "recommendation")

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> str:
        """
        resource type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "resource_type")

    @property
    @pulumi.getter(name="serviceType")
    def service_type(self) -> str:
        """
        service type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "service_type")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The current state of the ResponderRule.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the target was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the target was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class GetTargetTargetDetectorRecipeEffectiveDetectorRuleDetailsResult(dict):
    def __init__(__self__, *,
                 condition_groups: Sequence['outputs.GetTargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConditionGroupResult'],
                 configurations: Sequence['outputs.GetTargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationResult'],
                 is_configuration_allowed: bool,
                 is_enabled: bool,
                 labels: Sequence[str],
                 risk_level: str):
        """
        :param Sequence['GetTargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConditionGroupArgs'] condition_groups: Condition group corresponding to each compartment
        :param Sequence['GetTargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationArgs'] configurations: ResponderRule configurations
        :param bool is_configuration_allowed: configuration allowed or not
        :param bool is_enabled: Identifies state for ResponderRule
        :param Sequence[str] labels: user defined labels for a detector rule
        :param str risk_level: The Risk Level
        """
        pulumi.set(__self__, "condition_groups", condition_groups)
        pulumi.set(__self__, "configurations", configurations)
        pulumi.set(__self__, "is_configuration_allowed", is_configuration_allowed)
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "risk_level", risk_level)

    @property
    @pulumi.getter(name="conditionGroups")
    def condition_groups(self) -> Sequence['outputs.GetTargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConditionGroupResult']:
        """
        Condition group corresponding to each compartment
        """
        return pulumi.get(self, "condition_groups")

    @property
    @pulumi.getter
    def configurations(self) -> Sequence['outputs.GetTargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationResult']:
        """
        ResponderRule configurations
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isConfigurationAllowed")
    def is_configuration_allowed(self) -> bool:
        """
        configuration allowed or not
        """
        return pulumi.get(self, "is_configuration_allowed")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        """
        Identifies state for ResponderRule
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def labels(self) -> Sequence[str]:
        """
        user defined labels for a detector rule
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="riskLevel")
    def risk_level(self) -> str:
        """
        The Risk Level
        """
        return pulumi.get(self, "risk_level")


@pulumi.output_type
class GetTargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConditionGroupResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 condition: str):
        """
        :param str compartment_id: Compartment Identifier
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "condition", condition)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        Compartment Identifier
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def condition(self) -> str:
        return pulumi.get(self, "condition")


@pulumi.output_type
class GetTargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationResult(dict):
    def __init__(__self__, *,
                 config_key: str,
                 data_type: str,
                 name: str,
                 value: str,
                 values: Sequence['outputs.GetTargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValueResult']):
        """
        :param str config_key: Unique name of the configuration
        :param str data_type: configuration data type
        :param str name: configuration name
        :param str value: configuration value
        :param Sequence['GetTargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValueArgs'] values: List of configuration values
        """
        pulumi.set(__self__, "config_key", config_key)
        pulumi.set(__self__, "data_type", data_type)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> str:
        """
        Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter(name="dataType")
    def data_type(self) -> str:
        """
        configuration data type
        """
        return pulumi.get(self, "data_type")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def values(self) -> Sequence['outputs.GetTargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValueResult']:
        """
        List of configuration values
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class GetTargetTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValueResult(dict):
    def __init__(__self__, *,
                 list_type: str,
                 managed_list_type: str,
                 value: str):
        """
        :param str list_type: configuration list item type, either CUSTOM or MANAGED
        :param str managed_list_type: type of the managed list
        :param str value: configuration value
        """
        pulumi.set(__self__, "list_type", list_type)
        pulumi.set(__self__, "managed_list_type", managed_list_type)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="listType")
    def list_type(self) -> str:
        """
        configuration list item type, either CUSTOM or MANAGED
        """
        return pulumi.get(self, "list_type")

    @property
    @pulumi.getter(name="managedListType")
    def managed_list_type(self) -> str:
        """
        type of the managed list
        """
        return pulumi.get(self, "managed_list_type")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetTargetTargetResponderRecipeResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 description: str,
                 display_name: str,
                 effective_responder_rules: Sequence['outputs.GetTargetTargetResponderRecipeEffectiveResponderRuleResult'],
                 id: str,
                 owner: str,
                 responder_recipe_id: str,
                 responder_rules: Sequence['outputs.GetTargetTargetResponderRecipeResponderRuleResult'],
                 time_created: str,
                 time_updated: str):
        """
        :param str compartment_id: Compartment Identifier
        :param str description: ResponderRule Description
        :param str display_name: ResponderRule Display Name
        :param Sequence['GetTargetTargetResponderRecipeEffectiveResponderRuleArgs'] effective_responder_rules: List of responder rules associated with the recipe after applying all defaults
        :param str id: Unique identifier of TargetResponderRecipe that is immutable on creation
        :param str owner: Owner of ResponderRecipe
        :param str responder_recipe_id: Unique identifier for Responder Recipe of which this is an extension
        :param Sequence['GetTargetTargetResponderRecipeResponderRuleArgs'] responder_rules: List of responder rules associated with the recipe - user input
        :param str time_created: The date and time the target was created. Format defined by RFC3339.
        :param str time_updated: The date and time the target was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "effective_responder_rules", effective_responder_rules)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "owner", owner)
        pulumi.set(__self__, "responder_recipe_id", responder_recipe_id)
        pulumi.set(__self__, "responder_rules", responder_rules)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        Compartment Identifier
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        ResponderRule Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        ResponderRule Display Name
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="effectiveResponderRules")
    def effective_responder_rules(self) -> Sequence['outputs.GetTargetTargetResponderRecipeEffectiveResponderRuleResult']:
        """
        List of responder rules associated with the recipe after applying all defaults
        """
        return pulumi.get(self, "effective_responder_rules")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Unique identifier of TargetResponderRecipe that is immutable on creation
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def owner(self) -> str:
        """
        Owner of ResponderRecipe
        """
        return pulumi.get(self, "owner")

    @property
    @pulumi.getter(name="responderRecipeId")
    def responder_recipe_id(self) -> str:
        """
        Unique identifier for Responder Recipe of which this is an extension
        """
        return pulumi.get(self, "responder_recipe_id")

    @property
    @pulumi.getter(name="responderRules")
    def responder_rules(self) -> Sequence['outputs.GetTargetTargetResponderRecipeResponderRuleResult']:
        """
        List of responder rules associated with the recipe - user input
        """
        return pulumi.get(self, "responder_rules")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the target was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the target was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class GetTargetTargetResponderRecipeEffectiveResponderRuleResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 description: str,
                 details: 'outputs.GetTargetTargetResponderRecipeEffectiveResponderRuleDetailsResult',
                 display_name: str,
                 lifecycle_details: str,
                 policies: Sequence[str],
                 responder_rule_id: str,
                 state: str,
                 supported_modes: Sequence[str],
                 time_created: str,
                 time_updated: str,
                 type: str):
        """
        :param str compartment_id: Compartment Identifier
        :param str description: ResponderRule Description
        :param 'GetTargetTargetResponderRecipeEffectiveResponderRuleDetailsArgs' details: Details of ResponderRule.
        :param str display_name: ResponderRule Display Name
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] policies: List of Policy
        :param str responder_rule_id: Identifier for ResponderRule.
        :param str state: The current state of the ResponderRule.
        :param Sequence[str] supported_modes: Supported Execution Modes
        :param str time_created: The date and time the target was created. Format defined by RFC3339.
        :param str time_updated: The date and time the target was updated. Format defined by RFC3339.
        :param str type: Type of Responder
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        pulumi.set(__self__, "policies", policies)
        pulumi.set(__self__, "responder_rule_id", responder_rule_id)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "supported_modes", supported_modes)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        Compartment Identifier
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        ResponderRule Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def details(self) -> 'outputs.GetTargetTargetResponderRecipeEffectiveResponderRuleDetailsResult':
        """
        Details of ResponderRule.
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        ResponderRule Display Name
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter
    def policies(self) -> Sequence[str]:
        """
        List of Policy
        """
        return pulumi.get(self, "policies")

    @property
    @pulumi.getter(name="responderRuleId")
    def responder_rule_id(self) -> str:
        """
        Identifier for ResponderRule.
        """
        return pulumi.get(self, "responder_rule_id")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The current state of the ResponderRule.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="supportedModes")
    def supported_modes(self) -> Sequence[str]:
        """
        Supported Execution Modes
        """
        return pulumi.get(self, "supported_modes")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the target was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the target was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Type of Responder
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetTargetTargetResponderRecipeEffectiveResponderRuleDetailsResult(dict):
    def __init__(__self__, *,
                 condition: str,
                 configurations: Sequence['outputs.GetTargetTargetResponderRecipeEffectiveResponderRuleDetailsConfigurationResult'],
                 is_enabled: bool,
                 mode: str):
        """
        :param Sequence['GetTargetTargetResponderRecipeEffectiveResponderRuleDetailsConfigurationArgs'] configurations: ResponderRule configurations
        :param bool is_enabled: Identifies state for ResponderRule
        :param str mode: Execution Mode for ResponderRule
        """
        pulumi.set(__self__, "condition", condition)
        pulumi.set(__self__, "configurations", configurations)
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def condition(self) -> str:
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter
    def configurations(self) -> Sequence['outputs.GetTargetTargetResponderRecipeEffectiveResponderRuleDetailsConfigurationResult']:
        """
        ResponderRule configurations
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        """
        Identifies state for ResponderRule
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        Execution Mode for ResponderRule
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class GetTargetTargetResponderRecipeEffectiveResponderRuleDetailsConfigurationResult(dict):
    def __init__(__self__, *,
                 config_key: str,
                 name: str,
                 value: str):
        """
        :param str config_key: Unique name of the configuration
        :param str name: configuration name
        :param str value: configuration value
        """
        pulumi.set(__self__, "config_key", config_key)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> str:
        """
        Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetTargetTargetResponderRecipeResponderRuleResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 description: str,
                 details: 'outputs.GetTargetTargetResponderRecipeResponderRuleDetailsResult',
                 display_name: str,
                 lifecycle_details: str,
                 policies: Sequence[str],
                 responder_rule_id: str,
                 state: str,
                 supported_modes: Sequence[str],
                 time_created: str,
                 time_updated: str,
                 type: str):
        """
        :param str compartment_id: Compartment Identifier
        :param str description: ResponderRule Description
        :param 'GetTargetTargetResponderRecipeResponderRuleDetailsArgs' details: Details of ResponderRule.
        :param str display_name: ResponderRule Display Name
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] policies: List of Policy
        :param str responder_rule_id: Identifier for ResponderRule.
        :param str state: The current state of the ResponderRule.
        :param Sequence[str] supported_modes: Supported Execution Modes
        :param str time_created: The date and time the target was created. Format defined by RFC3339.
        :param str time_updated: The date and time the target was updated. Format defined by RFC3339.
        :param str type: Type of Responder
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        pulumi.set(__self__, "policies", policies)
        pulumi.set(__self__, "responder_rule_id", responder_rule_id)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "supported_modes", supported_modes)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        Compartment Identifier
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        ResponderRule Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def details(self) -> 'outputs.GetTargetTargetResponderRecipeResponderRuleDetailsResult':
        """
        Details of ResponderRule.
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        ResponderRule Display Name
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter
    def policies(self) -> Sequence[str]:
        """
        List of Policy
        """
        return pulumi.get(self, "policies")

    @property
    @pulumi.getter(name="responderRuleId")
    def responder_rule_id(self) -> str:
        """
        Identifier for ResponderRule.
        """
        return pulumi.get(self, "responder_rule_id")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The current state of the ResponderRule.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="supportedModes")
    def supported_modes(self) -> Sequence[str]:
        """
        Supported Execution Modes
        """
        return pulumi.get(self, "supported_modes")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the target was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the target was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Type of Responder
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetTargetTargetResponderRecipeResponderRuleDetailsResult(dict):
    def __init__(__self__, *,
                 condition: str,
                 configurations: Sequence['outputs.GetTargetTargetResponderRecipeResponderRuleDetailsConfigurationResult'],
                 is_enabled: bool,
                 mode: str):
        """
        :param Sequence['GetTargetTargetResponderRecipeResponderRuleDetailsConfigurationArgs'] configurations: ResponderRule configurations
        :param bool is_enabled: Identifies state for ResponderRule
        :param str mode: Execution Mode for ResponderRule
        """
        pulumi.set(__self__, "condition", condition)
        pulumi.set(__self__, "configurations", configurations)
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def condition(self) -> str:
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter
    def configurations(self) -> Sequence['outputs.GetTargetTargetResponderRecipeResponderRuleDetailsConfigurationResult']:
        """
        ResponderRule configurations
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        """
        Identifies state for ResponderRule
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        Execution Mode for ResponderRule
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class GetTargetTargetResponderRecipeResponderRuleDetailsConfigurationResult(dict):
    def __init__(__self__, *,
                 config_key: str,
                 name: str,
                 value: str):
        """
        :param str config_key: Unique name of the configuration
        :param str name: configuration name
        :param str value: configuration value
        """
        pulumi.set(__self__, "config_key", config_key)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> str:
        """
        Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetTargetsFilterResult(dict):
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str],
                 regex: Optional[bool] = None):
        """
        :param str name: configuration name
        :param Sequence[str] values: List of configuration values
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)
        if regex is not None:
            pulumi.set(__self__, "regex", regex)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        List of configuration values
        """
        return pulumi.get(self, "values")

    @property
    @pulumi.getter
    def regex(self) -> Optional[bool]:
        return pulumi.get(self, "regex")


@pulumi.output_type
class GetTargetsTargetCollectionResult(dict):
    def __init__(__self__, *,
                 items: Sequence['outputs.GetTargetsTargetCollectionItemResult']):
        pulumi.set(__self__, "items", items)

    @property
    @pulumi.getter
    def items(self) -> Sequence['outputs.GetTargetsTargetCollectionItemResult']:
        return pulumi.get(self, "items")


@pulumi.output_type
class GetTargetsTargetCollectionItemResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 defined_tags: Mapping[str, Any],
                 description: str,
                 display_name: str,
                 freeform_tags: Mapping[str, Any],
                 id: str,
                 inherited_by_compartments: Sequence[str],
                 lifecyle_details: str,
                 recipe_count: int,
                 state: str,
                 system_tags: Mapping[str, Any],
                 target_detector_recipes: Sequence['outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeResult'],
                 target_resource_id: str,
                 target_resource_type: str,
                 target_responder_recipes: Sequence['outputs.GetTargetsTargetCollectionItemTargetResponderRecipeResult'],
                 time_created: str,
                 time_updated: str):
        """
        :param str compartment_id: The ID of the compartment in which to list resources.
        :param Mapping[str, Any] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
        :param str description: ResponderRule Description
        :param str display_name: A filter to return only resources that match the entire display name given.
        :param Mapping[str, Any] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
        :param str id: Unique identifier of TargetResponderRecipe that is immutable on creation
        :param Sequence[str] inherited_by_compartments: List of inherited compartments
        :param str lifecyle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param int recipe_count: Total number of recipes attached to target
        :param str state: The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        :param Mapping[str, Any] system_tags: System tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). System tags can be viewed by users, but can only be created by the system.  Example: `{"orcl-cloud.free-tier-retained": "true"}`
        :param Sequence['GetTargetsTargetCollectionItemTargetDetectorRecipeArgs'] target_detector_recipes: List of detector recipes associated with target
        :param str target_resource_id: Resource ID which the target uses to monitor
        :param str target_resource_type: possible type of targets
        :param Sequence['GetTargetsTargetCollectionItemTargetResponderRecipeArgs'] target_responder_recipes: List of responder recipes associated with target
        :param str time_created: The date and time the target was created. Format defined by RFC3339.
        :param str time_updated: The date and time the target was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "defined_tags", defined_tags)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "freeform_tags", freeform_tags)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "inherited_by_compartments", inherited_by_compartments)
        pulumi.set(__self__, "lifecyle_details", lifecyle_details)
        pulumi.set(__self__, "recipe_count", recipe_count)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "system_tags", system_tags)
        pulumi.set(__self__, "target_detector_recipes", target_detector_recipes)
        pulumi.set(__self__, "target_resource_id", target_resource_id)
        pulumi.set(__self__, "target_resource_type", target_resource_type)
        pulumi.set(__self__, "target_responder_recipes", target_responder_recipes)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        The ID of the compartment in which to list resources.
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter(name="definedTags")
    def defined_tags(self) -> Mapping[str, Any]:
        """
        Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
        """
        return pulumi.get(self, "defined_tags")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        ResponderRule Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        A filter to return only resources that match the entire display name given.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="freeformTags")
    def freeform_tags(self) -> Mapping[str, Any]:
        """
        Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
        """
        return pulumi.get(self, "freeform_tags")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Unique identifier of TargetResponderRecipe that is immutable on creation
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="inheritedByCompartments")
    def inherited_by_compartments(self) -> Sequence[str]:
        """
        List of inherited compartments
        """
        return pulumi.get(self, "inherited_by_compartments")

    @property
    @pulumi.getter(name="lifecyleDetails")
    def lifecyle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecyle_details")

    @property
    @pulumi.getter(name="recipeCount")
    def recipe_count(self) -> int:
        """
        Total number of recipes attached to target
        """
        return pulumi.get(self, "recipe_count")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="systemTags")
    def system_tags(self) -> Mapping[str, Any]:
        """
        System tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). System tags can be viewed by users, but can only be created by the system.  Example: `{"orcl-cloud.free-tier-retained": "true"}`
        """
        return pulumi.get(self, "system_tags")

    @property
    @pulumi.getter(name="targetDetectorRecipes")
    def target_detector_recipes(self) -> Sequence['outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeResult']:
        """
        List of detector recipes associated with target
        """
        return pulumi.get(self, "target_detector_recipes")

    @property
    @pulumi.getter(name="targetResourceId")
    def target_resource_id(self) -> str:
        """
        Resource ID which the target uses to monitor
        """
        return pulumi.get(self, "target_resource_id")

    @property
    @pulumi.getter(name="targetResourceType")
    def target_resource_type(self) -> str:
        """
        possible type of targets
        """
        return pulumi.get(self, "target_resource_type")

    @property
    @pulumi.getter(name="targetResponderRecipes")
    def target_responder_recipes(self) -> Sequence['outputs.GetTargetsTargetCollectionItemTargetResponderRecipeResult']:
        """
        List of responder recipes associated with target
        """
        return pulumi.get(self, "target_responder_recipes")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the target was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the target was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class GetTargetsTargetCollectionItemTargetDetectorRecipeResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 description: str,
                 detector: str,
                 detector_recipe_id: str,
                 detector_rules: Sequence['outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleResult'],
                 display_name: str,
                 effective_detector_rules: Sequence['outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleResult'],
                 id: str,
                 owner: str,
                 state: str,
                 time_created: str,
                 time_updated: str):
        """
        :param str compartment_id: The ID of the compartment in which to list resources.
        :param str description: ResponderRule Description
        :param str detector: detector for the rule
        :param str detector_recipe_id: Unique identifier for Detector Recipe of which this is an extension
        :param Sequence['GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleArgs'] detector_rules: List of detector rules for the detector type for recipe - user input
        :param str display_name: A filter to return only resources that match the entire display name given.
        :param Sequence['GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleArgs'] effective_detector_rules: List of effective detector rules for the detector type for recipe after applying defaults
        :param str id: Unique identifier of TargetResponderRecipe that is immutable on creation
        :param str owner: Owner of ResponderRecipe
        :param str state: The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        :param str time_created: The date and time the target was created. Format defined by RFC3339.
        :param str time_updated: The date and time the target was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "detector", detector)
        pulumi.set(__self__, "detector_recipe_id", detector_recipe_id)
        pulumi.set(__self__, "detector_rules", detector_rules)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "effective_detector_rules", effective_detector_rules)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "owner", owner)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        The ID of the compartment in which to list resources.
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        ResponderRule Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def detector(self) -> str:
        """
        detector for the rule
        """
        return pulumi.get(self, "detector")

    @property
    @pulumi.getter(name="detectorRecipeId")
    def detector_recipe_id(self) -> str:
        """
        Unique identifier for Detector Recipe of which this is an extension
        """
        return pulumi.get(self, "detector_recipe_id")

    @property
    @pulumi.getter(name="detectorRules")
    def detector_rules(self) -> Sequence['outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleResult']:
        """
        List of detector rules for the detector type for recipe - user input
        """
        return pulumi.get(self, "detector_rules")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        A filter to return only resources that match the entire display name given.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="effectiveDetectorRules")
    def effective_detector_rules(self) -> Sequence['outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleResult']:
        """
        List of effective detector rules for the detector type for recipe after applying defaults
        """
        return pulumi.get(self, "effective_detector_rules")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Unique identifier of TargetResponderRecipe that is immutable on creation
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def owner(self) -> str:
        """
        Owner of ResponderRecipe
        """
        return pulumi.get(self, "owner")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the target was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the target was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleResult(dict):
    def __init__(__self__, *,
                 description: str,
                 details: 'outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleDetailsResult',
                 detector: str,
                 detector_rule_id: str,
                 display_name: str,
                 lifecycle_details: str,
                 managed_list_types: Sequence[str],
                 recommendation: str,
                 resource_type: str,
                 service_type: str,
                 state: str,
                 time_created: str,
                 time_updated: str):
        """
        :param str description: ResponderRule Description
        :param 'GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleDetailsArgs' details: Details of ResponderRule.
        :param str detector: detector for the rule
        :param str detector_rule_id: The unique identifier of the detector rule
        :param str display_name: A filter to return only resources that match the entire display name given.
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] managed_list_types: List of cloudguard managed list types related to this rule
        :param str recommendation: Recommendation for TargetDetectorRecipeDetectorRule
        :param str resource_type: resource type of the configuration to which the rule is applied
        :param str service_type: service type of the configuration to which the rule is applied
        :param str state: The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        :param str time_created: The date and time the target was created. Format defined by RFC3339.
        :param str time_updated: The date and time the target was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "detector", detector)
        pulumi.set(__self__, "detector_rule_id", detector_rule_id)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        pulumi.set(__self__, "managed_list_types", managed_list_types)
        pulumi.set(__self__, "recommendation", recommendation)
        pulumi.set(__self__, "resource_type", resource_type)
        pulumi.set(__self__, "service_type", service_type)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        ResponderRule Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def details(self) -> 'outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleDetailsResult':
        """
        Details of ResponderRule.
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter
    def detector(self) -> str:
        """
        detector for the rule
        """
        return pulumi.get(self, "detector")

    @property
    @pulumi.getter(name="detectorRuleId")
    def detector_rule_id(self) -> str:
        """
        The unique identifier of the detector rule
        """
        return pulumi.get(self, "detector_rule_id")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        A filter to return only resources that match the entire display name given.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter(name="managedListTypes")
    def managed_list_types(self) -> Sequence[str]:
        """
        List of cloudguard managed list types related to this rule
        """
        return pulumi.get(self, "managed_list_types")

    @property
    @pulumi.getter
    def recommendation(self) -> str:
        """
        Recommendation for TargetDetectorRecipeDetectorRule
        """
        return pulumi.get(self, "recommendation")

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> str:
        """
        resource type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "resource_type")

    @property
    @pulumi.getter(name="serviceType")
    def service_type(self) -> str:
        """
        service type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "service_type")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the target was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the target was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleDetailsResult(dict):
    def __init__(__self__, *,
                 condition_groups: Sequence['outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleDetailsConditionGroupResult'],
                 configurations: Sequence['outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleDetailsConfigurationResult'],
                 is_configuration_allowed: bool,
                 is_enabled: bool,
                 labels: Sequence[str],
                 risk_level: str):
        """
        :param Sequence['GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleDetailsConditionGroupArgs'] condition_groups: Condition group corresponding to each compartment
        :param Sequence['GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleDetailsConfigurationArgs'] configurations: ResponderRule configurations
        :param bool is_configuration_allowed: configuration allowed or not
        :param bool is_enabled: Identifies state for ResponderRule
        :param Sequence[str] labels: user defined labels for a detector rule
        :param str risk_level: The Risk Level
        """
        pulumi.set(__self__, "condition_groups", condition_groups)
        pulumi.set(__self__, "configurations", configurations)
        pulumi.set(__self__, "is_configuration_allowed", is_configuration_allowed)
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "risk_level", risk_level)

    @property
    @pulumi.getter(name="conditionGroups")
    def condition_groups(self) -> Sequence['outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleDetailsConditionGroupResult']:
        """
        Condition group corresponding to each compartment
        """
        return pulumi.get(self, "condition_groups")

    @property
    @pulumi.getter
    def configurations(self) -> Sequence['outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleDetailsConfigurationResult']:
        """
        ResponderRule configurations
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isConfigurationAllowed")
    def is_configuration_allowed(self) -> bool:
        """
        configuration allowed or not
        """
        return pulumi.get(self, "is_configuration_allowed")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        """
        Identifies state for ResponderRule
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def labels(self) -> Sequence[str]:
        """
        user defined labels for a detector rule
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="riskLevel")
    def risk_level(self) -> str:
        """
        The Risk Level
        """
        return pulumi.get(self, "risk_level")


@pulumi.output_type
class GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleDetailsConditionGroupResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 condition: str):
        """
        :param str compartment_id: The ID of the compartment in which to list resources.
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "condition", condition)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        The ID of the compartment in which to list resources.
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def condition(self) -> str:
        return pulumi.get(self, "condition")


@pulumi.output_type
class GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleDetailsConfigurationResult(dict):
    def __init__(__self__, *,
                 config_key: str,
                 data_type: str,
                 name: str,
                 value: str,
                 values: Sequence['outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleDetailsConfigurationValueResult']):
        """
        :param str config_key: Unique name of the configuration
        :param str data_type: configuration data type
        :param str name: configuration name
        :param str value: configuration value
        :param Sequence['GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleDetailsConfigurationValueArgs'] values: List of configuration values
        """
        pulumi.set(__self__, "config_key", config_key)
        pulumi.set(__self__, "data_type", data_type)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> str:
        """
        Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter(name="dataType")
    def data_type(self) -> str:
        """
        configuration data type
        """
        return pulumi.get(self, "data_type")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def values(self) -> Sequence['outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleDetailsConfigurationValueResult']:
        """
        List of configuration values
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class GetTargetsTargetCollectionItemTargetDetectorRecipeDetectorRuleDetailsConfigurationValueResult(dict):
    def __init__(__self__, *,
                 list_type: str,
                 managed_list_type: str,
                 value: str):
        """
        :param str list_type: configuration list item type, either CUSTOM or MANAGED
        :param str managed_list_type: type of the managed list
        :param str value: configuration value
        """
        pulumi.set(__self__, "list_type", list_type)
        pulumi.set(__self__, "managed_list_type", managed_list_type)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="listType")
    def list_type(self) -> str:
        """
        configuration list item type, either CUSTOM or MANAGED
        """
        return pulumi.get(self, "list_type")

    @property
    @pulumi.getter(name="managedListType")
    def managed_list_type(self) -> str:
        """
        type of the managed list
        """
        return pulumi.get(self, "managed_list_type")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleResult(dict):
    def __init__(__self__, *,
                 description: str,
                 details: 'outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleDetailsResult',
                 detector: str,
                 detector_rule_id: str,
                 display_name: str,
                 lifecycle_details: str,
                 managed_list_types: Sequence[str],
                 recommendation: str,
                 resource_type: str,
                 service_type: str,
                 state: str,
                 time_created: str,
                 time_updated: str):
        """
        :param str description: ResponderRule Description
        :param 'GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleDetailsArgs' details: Details of ResponderRule.
        :param str detector: detector for the rule
        :param str detector_rule_id: The unique identifier of the detector rule
        :param str display_name: A filter to return only resources that match the entire display name given.
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] managed_list_types: List of cloudguard managed list types related to this rule
        :param str recommendation: Recommendation for TargetDetectorRecipeDetectorRule
        :param str resource_type: resource type of the configuration to which the rule is applied
        :param str service_type: service type of the configuration to which the rule is applied
        :param str state: The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        :param str time_created: The date and time the target was created. Format defined by RFC3339.
        :param str time_updated: The date and time the target was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "detector", detector)
        pulumi.set(__self__, "detector_rule_id", detector_rule_id)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        pulumi.set(__self__, "managed_list_types", managed_list_types)
        pulumi.set(__self__, "recommendation", recommendation)
        pulumi.set(__self__, "resource_type", resource_type)
        pulumi.set(__self__, "service_type", service_type)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        ResponderRule Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def details(self) -> 'outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleDetailsResult':
        """
        Details of ResponderRule.
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter
    def detector(self) -> str:
        """
        detector for the rule
        """
        return pulumi.get(self, "detector")

    @property
    @pulumi.getter(name="detectorRuleId")
    def detector_rule_id(self) -> str:
        """
        The unique identifier of the detector rule
        """
        return pulumi.get(self, "detector_rule_id")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        A filter to return only resources that match the entire display name given.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter(name="managedListTypes")
    def managed_list_types(self) -> Sequence[str]:
        """
        List of cloudguard managed list types related to this rule
        """
        return pulumi.get(self, "managed_list_types")

    @property
    @pulumi.getter
    def recommendation(self) -> str:
        """
        Recommendation for TargetDetectorRecipeDetectorRule
        """
        return pulumi.get(self, "recommendation")

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> str:
        """
        resource type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "resource_type")

    @property
    @pulumi.getter(name="serviceType")
    def service_type(self) -> str:
        """
        service type of the configuration to which the rule is applied
        """
        return pulumi.get(self, "service_type")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the target was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the target was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleDetailsResult(dict):
    def __init__(__self__, *,
                 condition_groups: Sequence['outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleDetailsConditionGroupResult'],
                 configurations: Sequence['outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationResult'],
                 is_configuration_allowed: bool,
                 is_enabled: bool,
                 labels: Sequence[str],
                 risk_level: str):
        """
        :param Sequence['GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleDetailsConditionGroupArgs'] condition_groups: Condition group corresponding to each compartment
        :param Sequence['GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationArgs'] configurations: ResponderRule configurations
        :param bool is_configuration_allowed: configuration allowed or not
        :param bool is_enabled: Identifies state for ResponderRule
        :param Sequence[str] labels: user defined labels for a detector rule
        :param str risk_level: The Risk Level
        """
        pulumi.set(__self__, "condition_groups", condition_groups)
        pulumi.set(__self__, "configurations", configurations)
        pulumi.set(__self__, "is_configuration_allowed", is_configuration_allowed)
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "risk_level", risk_level)

    @property
    @pulumi.getter(name="conditionGroups")
    def condition_groups(self) -> Sequence['outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleDetailsConditionGroupResult']:
        """
        Condition group corresponding to each compartment
        """
        return pulumi.get(self, "condition_groups")

    @property
    @pulumi.getter
    def configurations(self) -> Sequence['outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationResult']:
        """
        ResponderRule configurations
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isConfigurationAllowed")
    def is_configuration_allowed(self) -> bool:
        """
        configuration allowed or not
        """
        return pulumi.get(self, "is_configuration_allowed")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        """
        Identifies state for ResponderRule
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def labels(self) -> Sequence[str]:
        """
        user defined labels for a detector rule
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="riskLevel")
    def risk_level(self) -> str:
        """
        The Risk Level
        """
        return pulumi.get(self, "risk_level")


@pulumi.output_type
class GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleDetailsConditionGroupResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 condition: str):
        """
        :param str compartment_id: The ID of the compartment in which to list resources.
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "condition", condition)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        The ID of the compartment in which to list resources.
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def condition(self) -> str:
        return pulumi.get(self, "condition")


@pulumi.output_type
class GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationResult(dict):
    def __init__(__self__, *,
                 config_key: str,
                 data_type: str,
                 name: str,
                 value: str,
                 values: Sequence['outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValueResult']):
        """
        :param str config_key: Unique name of the configuration
        :param str data_type: configuration data type
        :param str name: configuration name
        :param str value: configuration value
        :param Sequence['GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValueArgs'] values: List of configuration values
        """
        pulumi.set(__self__, "config_key", config_key)
        pulumi.set(__self__, "data_type", data_type)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> str:
        """
        Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter(name="dataType")
    def data_type(self) -> str:
        """
        configuration data type
        """
        return pulumi.get(self, "data_type")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def values(self) -> Sequence['outputs.GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValueResult']:
        """
        List of configuration values
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class GetTargetsTargetCollectionItemTargetDetectorRecipeEffectiveDetectorRuleDetailsConfigurationValueResult(dict):
    def __init__(__self__, *,
                 list_type: str,
                 managed_list_type: str,
                 value: str):
        """
        :param str list_type: configuration list item type, either CUSTOM or MANAGED
        :param str managed_list_type: type of the managed list
        :param str value: configuration value
        """
        pulumi.set(__self__, "list_type", list_type)
        pulumi.set(__self__, "managed_list_type", managed_list_type)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="listType")
    def list_type(self) -> str:
        """
        configuration list item type, either CUSTOM or MANAGED
        """
        return pulumi.get(self, "list_type")

    @property
    @pulumi.getter(name="managedListType")
    def managed_list_type(self) -> str:
        """
        type of the managed list
        """
        return pulumi.get(self, "managed_list_type")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetTargetsTargetCollectionItemTargetResponderRecipeResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 description: str,
                 display_name: str,
                 effective_responder_rules: Sequence['outputs.GetTargetsTargetCollectionItemTargetResponderRecipeEffectiveResponderRuleResult'],
                 id: str,
                 owner: str,
                 responder_recipe_id: str,
                 responder_rules: Sequence['outputs.GetTargetsTargetCollectionItemTargetResponderRecipeResponderRuleResult'],
                 time_created: str,
                 time_updated: str):
        """
        :param str compartment_id: The ID of the compartment in which to list resources.
        :param str description: ResponderRule Description
        :param str display_name: A filter to return only resources that match the entire display name given.
        :param Sequence['GetTargetsTargetCollectionItemTargetResponderRecipeEffectiveResponderRuleArgs'] effective_responder_rules: List of responder rules associated with the recipe after applying all defaults
        :param str id: Unique identifier of TargetResponderRecipe that is immutable on creation
        :param str owner: Owner of ResponderRecipe
        :param str responder_recipe_id: Unique identifier for Responder Recipe of which this is an extension
        :param Sequence['GetTargetsTargetCollectionItemTargetResponderRecipeResponderRuleArgs'] responder_rules: List of responder rules associated with the recipe - user input
        :param str time_created: The date and time the target was created. Format defined by RFC3339.
        :param str time_updated: The date and time the target was updated. Format defined by RFC3339.
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "effective_responder_rules", effective_responder_rules)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "owner", owner)
        pulumi.set(__self__, "responder_recipe_id", responder_recipe_id)
        pulumi.set(__self__, "responder_rules", responder_rules)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        The ID of the compartment in which to list resources.
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        ResponderRule Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        A filter to return only resources that match the entire display name given.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="effectiveResponderRules")
    def effective_responder_rules(self) -> Sequence['outputs.GetTargetsTargetCollectionItemTargetResponderRecipeEffectiveResponderRuleResult']:
        """
        List of responder rules associated with the recipe after applying all defaults
        """
        return pulumi.get(self, "effective_responder_rules")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Unique identifier of TargetResponderRecipe that is immutable on creation
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def owner(self) -> str:
        """
        Owner of ResponderRecipe
        """
        return pulumi.get(self, "owner")

    @property
    @pulumi.getter(name="responderRecipeId")
    def responder_recipe_id(self) -> str:
        """
        Unique identifier for Responder Recipe of which this is an extension
        """
        return pulumi.get(self, "responder_recipe_id")

    @property
    @pulumi.getter(name="responderRules")
    def responder_rules(self) -> Sequence['outputs.GetTargetsTargetCollectionItemTargetResponderRecipeResponderRuleResult']:
        """
        List of responder rules associated with the recipe - user input
        """
        return pulumi.get(self, "responder_rules")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the target was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the target was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class GetTargetsTargetCollectionItemTargetResponderRecipeEffectiveResponderRuleResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 description: str,
                 details: 'outputs.GetTargetsTargetCollectionItemTargetResponderRecipeEffectiveResponderRuleDetailsResult',
                 display_name: str,
                 lifecycle_details: str,
                 policies: Sequence[str],
                 responder_rule_id: str,
                 state: str,
                 supported_modes: Sequence[str],
                 time_created: str,
                 time_updated: str,
                 type: str):
        """
        :param str compartment_id: The ID of the compartment in which to list resources.
        :param str description: ResponderRule Description
        :param 'GetTargetsTargetCollectionItemTargetResponderRecipeEffectiveResponderRuleDetailsArgs' details: Details of ResponderRule.
        :param str display_name: A filter to return only resources that match the entire display name given.
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] policies: List of Policy
        :param str responder_rule_id: Identifier for ResponderRule.
        :param str state: The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        :param Sequence[str] supported_modes: Supported Execution Modes
        :param str time_created: The date and time the target was created. Format defined by RFC3339.
        :param str time_updated: The date and time the target was updated. Format defined by RFC3339.
        :param str type: Type of Responder
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        pulumi.set(__self__, "policies", policies)
        pulumi.set(__self__, "responder_rule_id", responder_rule_id)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "supported_modes", supported_modes)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        The ID of the compartment in which to list resources.
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        ResponderRule Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def details(self) -> 'outputs.GetTargetsTargetCollectionItemTargetResponderRecipeEffectiveResponderRuleDetailsResult':
        """
        Details of ResponderRule.
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        A filter to return only resources that match the entire display name given.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter
    def policies(self) -> Sequence[str]:
        """
        List of Policy
        """
        return pulumi.get(self, "policies")

    @property
    @pulumi.getter(name="responderRuleId")
    def responder_rule_id(self) -> str:
        """
        Identifier for ResponderRule.
        """
        return pulumi.get(self, "responder_rule_id")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="supportedModes")
    def supported_modes(self) -> Sequence[str]:
        """
        Supported Execution Modes
        """
        return pulumi.get(self, "supported_modes")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the target was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the target was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Type of Responder
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetTargetsTargetCollectionItemTargetResponderRecipeEffectiveResponderRuleDetailsResult(dict):
    def __init__(__self__, *,
                 condition: str,
                 configurations: Sequence['outputs.GetTargetsTargetCollectionItemTargetResponderRecipeEffectiveResponderRuleDetailsConfigurationResult'],
                 is_enabled: bool,
                 mode: str):
        """
        :param Sequence['GetTargetsTargetCollectionItemTargetResponderRecipeEffectiveResponderRuleDetailsConfigurationArgs'] configurations: ResponderRule configurations
        :param bool is_enabled: Identifies state for ResponderRule
        :param str mode: Execution Mode for ResponderRule
        """
        pulumi.set(__self__, "condition", condition)
        pulumi.set(__self__, "configurations", configurations)
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def condition(self) -> str:
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter
    def configurations(self) -> Sequence['outputs.GetTargetsTargetCollectionItemTargetResponderRecipeEffectiveResponderRuleDetailsConfigurationResult']:
        """
        ResponderRule configurations
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        """
        Identifies state for ResponderRule
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        Execution Mode for ResponderRule
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class GetTargetsTargetCollectionItemTargetResponderRecipeEffectiveResponderRuleDetailsConfigurationResult(dict):
    def __init__(__self__, *,
                 config_key: str,
                 name: str,
                 value: str):
        """
        :param str config_key: Unique name of the configuration
        :param str name: configuration name
        :param str value: configuration value
        """
        pulumi.set(__self__, "config_key", config_key)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> str:
        """
        Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetTargetsTargetCollectionItemTargetResponderRecipeResponderRuleResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 description: str,
                 details: 'outputs.GetTargetsTargetCollectionItemTargetResponderRecipeResponderRuleDetailsResult',
                 display_name: str,
                 lifecycle_details: str,
                 policies: Sequence[str],
                 responder_rule_id: str,
                 state: str,
                 supported_modes: Sequence[str],
                 time_created: str,
                 time_updated: str,
                 type: str):
        """
        :param str compartment_id: The ID of the compartment in which to list resources.
        :param str description: ResponderRule Description
        :param 'GetTargetsTargetCollectionItemTargetResponderRecipeResponderRuleDetailsArgs' details: Details of ResponderRule.
        :param str display_name: A filter to return only resources that match the entire display name given.
        :param str lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        :param Sequence[str] policies: List of Policy
        :param str responder_rule_id: Identifier for ResponderRule.
        :param str state: The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        :param Sequence[str] supported_modes: Supported Execution Modes
        :param str time_created: The date and time the target was created. Format defined by RFC3339.
        :param str time_updated: The date and time the target was updated. Format defined by RFC3339.
        :param str type: Type of Responder
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        pulumi.set(__self__, "policies", policies)
        pulumi.set(__self__, "responder_rule_id", responder_rule_id)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "supported_modes", supported_modes)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        The ID of the compartment in which to list resources.
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        ResponderRule Description
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def details(self) -> 'outputs.GetTargetsTargetCollectionItemTargetResponderRecipeResponderRuleDetailsResult':
        """
        Details of ResponderRule.
        """
        return pulumi.get(self, "details")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        A filter to return only resources that match the entire display name given.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter
    def policies(self) -> Sequence[str]:
        """
        List of Policy
        """
        return pulumi.get(self, "policies")

    @property
    @pulumi.getter(name="responderRuleId")
    def responder_rule_id(self) -> str:
        """
        Identifier for ResponderRule.
        """
        return pulumi.get(self, "responder_rule_id")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The field life cycle state. Only one state can be provided. Default value for state is active. If no value is specified state is active.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="supportedModes")
    def supported_modes(self) -> Sequence[str]:
        """
        Supported Execution Modes
        """
        return pulumi.get(self, "supported_modes")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the target was created. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the target was updated. Format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Type of Responder
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetTargetsTargetCollectionItemTargetResponderRecipeResponderRuleDetailsResult(dict):
    def __init__(__self__, *,
                 condition: str,
                 configurations: Sequence['outputs.GetTargetsTargetCollectionItemTargetResponderRecipeResponderRuleDetailsConfigurationResult'],
                 is_enabled: bool,
                 mode: str):
        """
        :param Sequence['GetTargetsTargetCollectionItemTargetResponderRecipeResponderRuleDetailsConfigurationArgs'] configurations: ResponderRule configurations
        :param bool is_enabled: Identifies state for ResponderRule
        :param str mode: Execution Mode for ResponderRule
        """
        pulumi.set(__self__, "condition", condition)
        pulumi.set(__self__, "configurations", configurations)
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def condition(self) -> str:
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter
    def configurations(self) -> Sequence['outputs.GetTargetsTargetCollectionItemTargetResponderRecipeResponderRuleDetailsConfigurationResult']:
        """
        ResponderRule configurations
        """
        return pulumi.get(self, "configurations")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        """
        Identifies state for ResponderRule
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        Execution Mode for ResponderRule
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class GetTargetsTargetCollectionItemTargetResponderRecipeResponderRuleDetailsConfigurationResult(dict):
    def __init__(__self__, *,
                 config_key: str,
                 name: str,
                 value: str):
        """
        :param str config_key: Unique name of the configuration
        :param str name: configuration name
        :param str value: configuration value
        """
        pulumi.set(__self__, "config_key", config_key)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="configKey")
    def config_key(self) -> str:
        """
        Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        configuration name
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        configuration value
        """
        return pulumi.get(self, "value")


