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

__all__ = [
    'CloudGuardDataSourceDataSourceDetailsArgs',
    'CloudGuardDataSourceDataSourceDetailsLoggingQueryDetailsArgs',
    'CloudGuardDataSourceDataSourceDetailsQueryStartTimeArgs',
    'CloudGuardDataSourceDataSourceDetectorMappingInfoArgs',
    'CloudGuardDataSourceRegionStatusDetailArgs',
    'DataMaskRuleTargetSelectedArgs',
    'DetectorRecipeDetectorRuleArgs',
    'DetectorRecipeDetectorRuleCandidateResponderRuleArgs',
    'DetectorRecipeDetectorRuleDetailsArgs',
    'DetectorRecipeDetectorRuleDetailsConfigurationArgs',
    'DetectorRecipeDetectorRuleDetailsConfigurationValueArgs',
    'DetectorRecipeDetectorRuleDetailsEntitiesMappingArgs',
    'DetectorRecipeDetectorRuleEntitiesMappingArgs',
    'DetectorRecipeEffectiveDetectorRuleArgs',
    'DetectorRecipeEffectiveDetectorRuleCandidateResponderRuleArgs',
    'DetectorRecipeEffectiveDetectorRuleDetailArgs',
    'DetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs',
    'DetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs',
    'DetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs',
    'ResponderRecipeEffectiveResponderRuleArgs',
    'ResponderRecipeEffectiveResponderRuleDetailArgs',
    'ResponderRecipeEffectiveResponderRuleDetailConfigurationArgs',
    'ResponderRecipeResponderRuleArgs',
    'ResponderRecipeResponderRuleDetailsArgs',
    'ResponderRecipeResponderRuleDetailsConfigurationArgs',
    'TargetTargetDetailArgs',
    'TargetTargetDetailTargetSecurityZoneRecipeArgs',
    'TargetTargetDetectorRecipeArgs',
    'TargetTargetDetectorRecipeDetectorRuleArgs',
    'TargetTargetDetectorRecipeDetectorRuleDetailsArgs',
    'TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroupArgs',
    'TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationArgs',
    'TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueArgs',
    'TargetTargetDetectorRecipeDetectorRuleEntitiesMappingArgs',
    'TargetTargetDetectorRecipeEffectiveDetectorRuleArgs',
    'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailArgs',
    'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConditionGroupArgs',
    'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs',
    'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs',
    'TargetTargetDetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs',
    'TargetTargetResponderRecipeArgs',
    'TargetTargetResponderRecipeEffectiveResponderRuleArgs',
    'TargetTargetResponderRecipeEffectiveResponderRuleDetailArgs',
    'TargetTargetResponderRecipeEffectiveResponderRuleDetailConfigurationArgs',
    'TargetTargetResponderRecipeResponderRuleArgs',
    'TargetTargetResponderRecipeResponderRuleDetailsArgs',
    'TargetTargetResponderRecipeResponderRuleDetailsConfigurationArgs',
    'GetDataMaskRulesFilterArgs',
    'GetDataSourceEventsFilterArgs',
    'GetDataSourcesFilterArgs',
    'GetDetectorRecipesFilterArgs',
    'GetGuardTargetsFilterArgs',
    'GetManagedListsFilterArgs',
    'GetProblemEntitiesFilterArgs',
    'GetResponderRecipesFilterArgs',
    'GetSecurityPoliciesFilterArgs',
    'GetSecurityRecipesFilterArgs',
    'GetSecurityZonesFilterArgs',
]

@pulumi.input_type
class CloudGuardDataSourceDataSourceDetailsArgs:
    def __init__(__self__, *,
                 data_source_feed_provider: pulumi.Input[str],
                 additional_entities_count: Optional[pulumi.Input[int]] = None,
                 interval_in_minutes: Optional[pulumi.Input[int]] = None,
                 logging_query_details: Optional[pulumi.Input['CloudGuardDataSourceDataSourceDetailsLoggingQueryDetailsArgs']] = None,
                 logging_query_type: Optional[pulumi.Input[str]] = None,
                 operator: Optional[pulumi.Input[str]] = None,
                 query: Optional[pulumi.Input[str]] = None,
                 query_start_time: Optional[pulumi.Input['CloudGuardDataSourceDataSourceDetailsQueryStartTimeArgs']] = None,
                 regions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 threshold: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] data_source_feed_provider: Possible type of dataSourceFeed Provider(LoggingQuery)
        :param pulumi.Input[int] additional_entities_count: (Updatable) The additional entities count used for data source query.
        :param pulumi.Input[int] interval_in_minutes: (Updatable) Interval in minutes that query is run periodically.
        :param pulumi.Input['CloudGuardDataSourceDataSourceDetailsLoggingQueryDetailsArgs'] logging_query_details: (Updatable) Additional details specific to the data source type (Sighting/Insight).
        :param pulumi.Input[str] logging_query_type: (Updatable) Logging query type for data source (Sighting/Insight)
        :param pulumi.Input[str] operator: (Updatable) Operator used in Data Soruce
        :param pulumi.Input[str] query: (Updatable) The continuous query expression that is run periodically.
        :param pulumi.Input['CloudGuardDataSourceDataSourceDetailsQueryStartTimeArgs'] query_start_time: (Updatable) Time when the query can start, if not specified it can start immediately.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] regions: (Updatable) Logging Query regions
        :param pulumi.Input[int] threshold: (Updatable) The integer value that must be exceeded, fall below or equal to (depending on the operator), the query result to trigger an event.
        """
        pulumi.set(__self__, "data_source_feed_provider", data_source_feed_provider)
        if additional_entities_count is not None:
            pulumi.set(__self__, "additional_entities_count", additional_entities_count)
        if interval_in_minutes is not None:
            pulumi.set(__self__, "interval_in_minutes", interval_in_minutes)
        if logging_query_details is not None:
            pulumi.set(__self__, "logging_query_details", logging_query_details)
        if logging_query_type is not None:
            pulumi.set(__self__, "logging_query_type", logging_query_type)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if query is not None:
            pulumi.set(__self__, "query", query)
        if query_start_time is not None:
            pulumi.set(__self__, "query_start_time", query_start_time)
        if regions is not None:
            pulumi.set(__self__, "regions", regions)
        if threshold is not None:
            pulumi.set(__self__, "threshold", threshold)

    @property
    @pulumi.getter(name="dataSourceFeedProvider")
    def data_source_feed_provider(self) -> pulumi.Input[str]:
        """
        Possible type of dataSourceFeed Provider(LoggingQuery)
        """
        return pulumi.get(self, "data_source_feed_provider")

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

    @property
    @pulumi.getter(name="additionalEntitiesCount")
    def additional_entities_count(self) -> Optional[pulumi.Input[int]]:
        """
        (Updatable) The additional entities count used for data source query.
        """
        return pulumi.get(self, "additional_entities_count")

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

    @property
    @pulumi.getter(name="intervalInMinutes")
    def interval_in_minutes(self) -> Optional[pulumi.Input[int]]:
        """
        (Updatable) Interval in minutes that query is run periodically.
        """
        return pulumi.get(self, "interval_in_minutes")

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

    @property
    @pulumi.getter(name="loggingQueryDetails")
    def logging_query_details(self) -> Optional[pulumi.Input['CloudGuardDataSourceDataSourceDetailsLoggingQueryDetailsArgs']]:
        """
        (Updatable) Additional details specific to the data source type (Sighting/Insight).
        """
        return pulumi.get(self, "logging_query_details")

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

    @property
    @pulumi.getter(name="loggingQueryType")
    def logging_query_type(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) Logging query type for data source (Sighting/Insight)
        """
        return pulumi.get(self, "logging_query_type")

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

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) Operator used in Data Soruce
        """
        return pulumi.get(self, "operator")

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

    @property
    @pulumi.getter
    def query(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The continuous query expression that is run periodically.
        """
        return pulumi.get(self, "query")

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

    @property
    @pulumi.getter(name="queryStartTime")
    def query_start_time(self) -> Optional[pulumi.Input['CloudGuardDataSourceDataSourceDetailsQueryStartTimeArgs']]:
        """
        (Updatable) Time when the query can start, if not specified it can start immediately.
        """
        return pulumi.get(self, "query_start_time")

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

    @property
    @pulumi.getter
    def regions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        (Updatable) Logging Query regions
        """
        return pulumi.get(self, "regions")

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

    @property
    @pulumi.getter
    def threshold(self) -> Optional[pulumi.Input[int]]:
        """
        (Updatable) The integer value that must be exceeded, fall below or equal to (depending on the operator), the query result to trigger an event.
        """
        return pulumi.get(self, "threshold")

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


@pulumi.input_type
class CloudGuardDataSourceDataSourceDetailsLoggingQueryDetailsArgs:
    def __init__(__self__, *,
                 logging_query_type: pulumi.Input[str],
                 key_entities_count: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] logging_query_type: (Updatable) Logging query type for data source (Sighting/Insight)
        :param pulumi.Input[int] key_entities_count: (Updatable) The key entities count used for data source query
        """
        pulumi.set(__self__, "logging_query_type", logging_query_type)
        if key_entities_count is not None:
            pulumi.set(__self__, "key_entities_count", key_entities_count)

    @property
    @pulumi.getter(name="loggingQueryType")
    def logging_query_type(self) -> pulumi.Input[str]:
        """
        (Updatable) Logging query type for data source (Sighting/Insight)
        """
        return pulumi.get(self, "logging_query_type")

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

    @property
    @pulumi.getter(name="keyEntitiesCount")
    def key_entities_count(self) -> Optional[pulumi.Input[int]]:
        """
        (Updatable) The key entities count used for data source query
        """
        return pulumi.get(self, "key_entities_count")

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


@pulumi.input_type
class CloudGuardDataSourceDataSourceDetailsQueryStartTimeArgs:
    def __init__(__self__, *,
                 start_policy_type: pulumi.Input[str],
                 query_start_time: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] start_policy_type: (Updatable) policy used for deciding the query start time
        :param pulumi.Input[str] query_start_time: (Updatable) Time when the query can start, if not specified it can start immediately.
        """
        pulumi.set(__self__, "start_policy_type", start_policy_type)
        if query_start_time is not None:
            pulumi.set(__self__, "query_start_time", query_start_time)

    @property
    @pulumi.getter(name="startPolicyType")
    def start_policy_type(self) -> pulumi.Input[str]:
        """
        (Updatable) policy used for deciding the query start time
        """
        return pulumi.get(self, "start_policy_type")

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

    @property
    @pulumi.getter(name="queryStartTime")
    def query_start_time(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) Time when the query can start, if not specified it can start immediately.
        """
        return pulumi.get(self, "query_start_time")

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


@pulumi.input_type
class CloudGuardDataSourceDataSourceDetectorMappingInfoArgs:
    def __init__(__self__, *,
                 detector_recipe_id: Optional[pulumi.Input[str]] = None,
                 detector_rule_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] detector_recipe_id: Id of the attached detectorRecipeId to the Data Source.
        :param pulumi.Input[str] detector_rule_id: Id of the attached detectorRuleId to the Data Source.
        """
        if detector_recipe_id is not None:
            pulumi.set(__self__, "detector_recipe_id", detector_recipe_id)
        if detector_rule_id is not None:
            pulumi.set(__self__, "detector_rule_id", detector_rule_id)

    @property
    @pulumi.getter(name="detectorRecipeId")
    def detector_recipe_id(self) -> Optional[pulumi.Input[str]]:
        """
        Id of the attached detectorRecipeId to the Data Source.
        """
        return pulumi.get(self, "detector_recipe_id")

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

    @property
    @pulumi.getter(name="detectorRuleId")
    def detector_rule_id(self) -> Optional[pulumi.Input[str]]:
        """
        Id of the attached detectorRuleId to the Data Source.
        """
        return pulumi.get(self, "detector_rule_id")

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


@pulumi.input_type
class CloudGuardDataSourceRegionStatusDetailArgs:
    def __init__(__self__, *,
                 region: Optional[pulumi.Input[str]] = None,
                 status: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] region: Data Source replication region.
        :param pulumi.Input[str] status: Status of data Source
        """
        if region is not None:
            pulumi.set(__self__, "region", region)
        if status is not None:
            pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        """
        Data Source replication region.
        """
        return pulumi.get(self, "region")

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

    @property
    @pulumi.getter
    def status(self) -> Optional[pulumi.Input[str]]:
        """
        Status of data Source
        """
        return pulumi.get(self, "status")

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


@pulumi.input_type
class DataMaskRuleTargetSelectedArgs:
    def __init__(__self__, *,
                 kind: pulumi.Input[str],
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] kind: (Updatable) Target selection.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: (Updatable) Types of Targets
               
               
               ** IMPORTANT **
               Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
        """
        pulumi.set(__self__, "kind", kind)
        if values is not None:
            pulumi.set(__self__, "values", values)

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

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

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


        ** IMPORTANT **
        Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
        """
        return pulumi.get(self, "values")

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


@pulumi.input_type
class DetectorRecipeDetectorRuleArgs:
    def __init__(__self__, *,
                 details: pulumi.Input['DetectorRecipeDetectorRuleDetailsArgs'],
                 detector_rule_id: pulumi.Input[str],
                 candidate_responder_rules: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleCandidateResponderRuleArgs']]]] = None,
                 data_source_id: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 detector: Optional[pulumi.Input[str]] = None,
                 display_name: Optional[pulumi.Input[str]] = None,
                 entities_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleEntitiesMappingArgs']]]] = None,
                 lifecycle_details: Optional[pulumi.Input[str]] = None,
                 managed_list_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 recommendation: Optional[pulumi.Input[str]] = None,
                 resource_type: Optional[pulumi.Input[str]] = None,
                 service_type: Optional[pulumi.Input[str]] = None,
                 state: Optional[pulumi.Input[str]] = None,
                 time_created: Optional[pulumi.Input[str]] = None,
                 time_updated: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['DetectorRecipeDetectorRuleDetailsArgs'] details: (Updatable) Details of a Detector Rule to be overriden in Detector Recipe
        :param pulumi.Input[str] detector_rule_id: (Updatable) DetectorRecipeRule Identifier
        :param pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleCandidateResponderRuleArgs']]] candidate_responder_rules: List of CandidateResponderRule related to this rule
        :param pulumi.Input[str] data_source_id: (Updatable) The id of the attached DataSource.
        :param pulumi.Input[str] description: (Updatable) Description for DetectorRecipeDetectorRule.
        :param pulumi.Input[str] detector: detector for the rule
        :param pulumi.Input[str] display_name: (Updatable) Detector recipe display name.
               
               Avoid entering confidential information.
        :param pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleEntitiesMappingArgs']]] entities_mappings: (Updatable) Data Source entities mapping for a Detector Rule
        :param pulumi.Input[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 pulumi.Input[Sequence[pulumi.Input[str]]] managed_list_types: List of cloudguard managed list types related to this rule
        :param pulumi.Input[str] recommendation: (Updatable) Recommendation for DetectorRecipeDetectorRule
        :param pulumi.Input[str] resource_type: resource type of the configuration to which the rule is applied
        :param pulumi.Input[str] service_type: service type of the configuration to which the rule is applied
        :param pulumi.Input[str] state: The current state of the resource.
        :param pulumi.Input[str] time_created: The date and time the detector recipe was created. Format defined by RFC3339.
        :param pulumi.Input[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 data_source_id is not None:
            pulumi.set(__self__, "data_source_id", data_source_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 entities_mappings is not None:
            pulumi.set(__self__, "entities_mappings", entities_mappings)
        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) -> pulumi.Input['DetectorRecipeDetectorRuleDetailsArgs']:
        """
        (Updatable) Details of a Detector Rule to be overriden in Detector Recipe
        """
        return pulumi.get(self, "details")

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

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

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

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

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

    @property
    @pulumi.getter(name="dataSourceId")
    def data_source_id(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The id of the attached DataSource.
        """
        return pulumi.get(self, "data_source_id")

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

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

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

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

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) Detector recipe display name.

        Avoid entering confidential information.
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter(name="entitiesMappings")
    def entities_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleEntitiesMappingArgs']]]]:
        """
        (Updatable) Data Source entities mapping for a Detector Rule
        """
        return pulumi.get(self, "entities_mappings")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class DetectorRecipeDetectorRuleCandidateResponderRuleArgs:
    def __init__(__self__, *,
                 display_name: Optional[pulumi.Input[str]] = None,
                 id: Optional[pulumi.Input[str]] = None,
                 is_preferred: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] display_name: (Updatable) Detector recipe display name.
               
               Avoid entering confidential information.
        :param pulumi.Input[str] id: Ocid for detector recipe
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        (Updatable) Detector recipe display name.

        Avoid entering confidential information.
        """
        return pulumi.get(self, "display_name")

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

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

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

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

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


@pulumi.input_type
class DetectorRecipeDetectorRuleDetailsArgs:
    def __init__(__self__, *,
                 is_enabled: pulumi.Input[bool],
                 risk_level: pulumi.Input[str],
                 condition: Optional[pulumi.Input[str]] = None,
                 configurations: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsConfigurationArgs']]]] = None,
                 data_source_id: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 entities_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsEntitiesMappingArgs']]]] = None,
                 is_configuration_allowed: Optional[pulumi.Input[bool]] = None,
                 labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 recommendation: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] is_enabled: (Updatable) Enables the control
        :param pulumi.Input[str] risk_level: (Updatable) The Risk Level
        :param pulumi.Input[str] condition: (Updatable) Base condition object
        :param pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsConfigurationArgs']]] configurations: (Updatable) Configuration details
        :param pulumi.Input[str] data_source_id: (Updatable) The id of the attached DataSource.
        :param pulumi.Input[str] description: (Updatable) Description for DetectorRecipeDetectorRule.
        :param pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsEntitiesMappingArgs']]] entities_mappings: (Updatable) Data Source entities mapping for a Detector Rule
        :param pulumi.Input[bool] is_configuration_allowed: configuration allowed or not
        :param pulumi.Input[Sequence[pulumi.Input[str]]] labels: (Updatable) user defined labels for a detector rule
        :param pulumi.Input[str] recommendation: (Updatable) Recommendation for DetectorRecipeDetectorRule
        """
        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 data_source_id is not None:
            pulumi.set(__self__, "data_source_id", data_source_id)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if entities_mappings is not None:
            pulumi.set(__self__, "entities_mappings", entities_mappings)
        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)
        if recommendation is not None:
            pulumi.set(__self__, "recommendation", recommendation)

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="dataSourceId")
    def data_source_id(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The id of the attached DataSource.
        """
        return pulumi.get(self, "data_source_id")

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

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

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

    @property
    @pulumi.getter(name="entitiesMappings")
    def entities_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsEntitiesMappingArgs']]]]:
        """
        (Updatable) Data Source entities mapping for a Detector Rule
        """
        return pulumi.get(self, "entities_mappings")

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

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

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

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

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

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

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


@pulumi.input_type
class DetectorRecipeDetectorRuleDetailsConfigurationArgs:
    def __init__(__self__, *,
                 config_key: pulumi.Input[str],
                 name: pulumi.Input[str],
                 data_type: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None,
                 values: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsConfigurationValueArgs']]]] = None):
        """
        :param pulumi.Input[str] config_key: (Updatable) Unique name of the configuration
        :param pulumi.Input[str] name: (Updatable) configuration name
        :param pulumi.Input[str] data_type: (Updatable) configuration data type
        :param pulumi.Input[str] value: (Updatable) configuration value
        :param pulumi.Input[Sequence[pulumi.Input['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) -> pulumi.Input[str]:
        """
        (Updatable) Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class DetectorRecipeDetectorRuleDetailsConfigurationValueArgs:
    def __init__(__self__, *,
                 list_type: pulumi.Input[str],
                 managed_list_type: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] list_type: (Updatable) configuration list item type, either CUSTOM or MANAGED
        :param pulumi.Input[str] managed_list_type: (Updatable) type of the managed list
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        (Updatable) configuration list item type, either CUSTOM or MANAGED
        """
        return pulumi.get(self, "list_type")

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

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

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

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

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


@pulumi.input_type
class DetectorRecipeDetectorRuleDetailsEntitiesMappingArgs:
    def __init__(__self__, *,
                 query_field: pulumi.Input[str],
                 display_name: Optional[pulumi.Input[str]] = None,
                 entity_type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] query_field: (Updatable) The entity value mapped to a data source query
        :param pulumi.Input[str] display_name: (Updatable) Detector recipe display name.
               
               Avoid entering confidential information.
        :param pulumi.Input[str] entity_type: (Updatable) Possible type of entity
        """
        pulumi.set(__self__, "query_field", query_field)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if entity_type is not None:
            pulumi.set(__self__, "entity_type", entity_type)

    @property
    @pulumi.getter(name="queryField")
    def query_field(self) -> pulumi.Input[str]:
        """
        (Updatable) The entity value mapped to a data source query
        """
        return pulumi.get(self, "query_field")

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) Detector recipe display name.

        Avoid entering confidential information.
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter(name="entityType")
    def entity_type(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) Possible type of entity
        """
        return pulumi.get(self, "entity_type")

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


@pulumi.input_type
class DetectorRecipeDetectorRuleEntitiesMappingArgs:
    def __init__(__self__, *,
                 display_name: Optional[pulumi.Input[str]] = None,
                 entity_type: Optional[pulumi.Input[str]] = None,
                 query_field: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] display_name: (Updatable) Detector recipe display name.
               
               Avoid entering confidential information.
        :param pulumi.Input[str] entity_type: (Updatable) Possible type of entity
        :param pulumi.Input[str] query_field: (Updatable) The entity value mapped to a data source query
        """
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if entity_type is not None:
            pulumi.set(__self__, "entity_type", entity_type)
        if query_field is not None:
            pulumi.set(__self__, "query_field", query_field)

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) Detector recipe display name.

        Avoid entering confidential information.
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter(name="entityType")
    def entity_type(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) Possible type of entity
        """
        return pulumi.get(self, "entity_type")

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

    @property
    @pulumi.getter(name="queryField")
    def query_field(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The entity value mapped to a data source query
        """
        return pulumi.get(self, "query_field")

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


@pulumi.input_type
class DetectorRecipeEffectiveDetectorRuleArgs:
    def __init__(__self__, *,
                 candidate_responder_rules: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleCandidateResponderRuleArgs']]]] = None,
                 data_source_id: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 details: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailArgs']]]] = None,
                 detector: Optional[pulumi.Input[str]] = None,
                 detector_rule_id: Optional[pulumi.Input[str]] = None,
                 display_name: Optional[pulumi.Input[str]] = None,
                 entities_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs']]]] = None,
                 lifecycle_details: Optional[pulumi.Input[str]] = None,
                 managed_list_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 recommendation: Optional[pulumi.Input[str]] = None,
                 resource_type: Optional[pulumi.Input[str]] = None,
                 service_type: Optional[pulumi.Input[str]] = None,
                 state: Optional[pulumi.Input[str]] = None,
                 time_created: Optional[pulumi.Input[str]] = None,
                 time_updated: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleCandidateResponderRuleArgs']]] candidate_responder_rules: List of CandidateResponderRule related to this rule
        :param pulumi.Input[str] data_source_id: (Updatable) The id of the attached DataSource.
        :param pulumi.Input[str] description: (Updatable) Description for DetectorRecipeDetectorRule.
        :param pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailArgs']]] details: (Updatable) Details of a Detector Rule to be overriden in Detector Recipe
        :param pulumi.Input[str] detector: detector for the rule
        :param pulumi.Input[str] detector_rule_id: (Updatable) DetectorRecipeRule Identifier
        :param pulumi.Input[str] display_name: (Updatable) Detector recipe display name.
               
               Avoid entering confidential information.
        :param pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs']]] entities_mappings: (Updatable) Data Source entities mapping for a Detector Rule
        :param pulumi.Input[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 pulumi.Input[Sequence[pulumi.Input[str]]] managed_list_types: List of cloudguard managed list types related to this rule
        :param pulumi.Input[str] recommendation: (Updatable) Recommendation for DetectorRecipeDetectorRule
        :param pulumi.Input[str] resource_type: resource type of the configuration to which the rule is applied
        :param pulumi.Input[str] service_type: service type of the configuration to which the rule is applied
        :param pulumi.Input[str] state: The current state of the resource.
        :param pulumi.Input[str] time_created: The date and time the detector recipe was created. Format defined by RFC3339.
        :param pulumi.Input[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 data_source_id is not None:
            pulumi.set(__self__, "data_source_id", data_source_id)
        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 entities_mappings is not None:
            pulumi.set(__self__, "entities_mappings", entities_mappings)
        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[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleCandidateResponderRuleArgs']]]]:
        """
        List of CandidateResponderRule related to this rule
        """
        return pulumi.get(self, "candidate_responder_rules")

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

    @property
    @pulumi.getter(name="dataSourceId")
    def data_source_id(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The id of the attached DataSource.
        """
        return pulumi.get(self, "data_source_id")

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) Detector recipe display name.

        Avoid entering confidential information.
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter(name="entitiesMappings")
    def entities_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs']]]]:
        """
        (Updatable) Data Source entities mapping for a Detector Rule
        """
        return pulumi.get(self, "entities_mappings")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class DetectorRecipeEffectiveDetectorRuleCandidateResponderRuleArgs:
    def __init__(__self__, *,
                 display_name: Optional[pulumi.Input[str]] = None,
                 id: Optional[pulumi.Input[str]] = None,
                 is_preferred: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] display_name: (Updatable) Detector recipe display name.
               
               Avoid entering confidential information.
        :param pulumi.Input[str] id: Ocid for detector recipe
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        (Updatable) Detector recipe display name.

        Avoid entering confidential information.
        """
        return pulumi.get(self, "display_name")

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

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

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

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

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


@pulumi.input_type
class DetectorRecipeEffectiveDetectorRuleDetailArgs:
    def __init__(__self__, *,
                 condition: Optional[pulumi.Input[str]] = None,
                 configurations: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs']]]] = None,
                 is_configuration_allowed: Optional[pulumi.Input[bool]] = None,
                 is_enabled: Optional[pulumi.Input[bool]] = None,
                 labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 risk_level: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] condition: (Updatable) Base condition object
        :param pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs']]] configurations: (Updatable) Configuration details
        :param pulumi.Input[bool] is_configuration_allowed: configuration allowed or not
        :param pulumi.Input[bool] is_enabled: (Updatable) Enables the control
        :param pulumi.Input[Sequence[pulumi.Input[str]]] labels: (Updatable) user defined labels for a detector rule
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        (Updatable) Base condition object
        """
        return pulumi.get(self, "condition")

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class DetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs:
    def __init__(__self__, *,
                 config_key: Optional[pulumi.Input[str]] = None,
                 data_type: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None,
                 values: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs']]]] = None):
        """
        :param pulumi.Input[str] config_key: (Updatable) Unique name of the configuration
        :param pulumi.Input[str] data_type: (Updatable) configuration data type
        :param pulumi.Input[str] name: (Updatable) configuration name
        :param pulumi.Input[str] value: (Updatable) configuration value
        :param pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs']]] 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[pulumi.Input[str]]:
        """
        (Updatable) Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class DetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs:
    def __init__(__self__, *,
                 list_type: Optional[pulumi.Input[str]] = None,
                 managed_list_type: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] list_type: (Updatable) configuration list item type, either CUSTOM or MANAGED
        :param pulumi.Input[str] managed_list_type: (Updatable) type of the managed list
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        (Updatable) configuration list item type, either CUSTOM or MANAGED
        """
        return pulumi.get(self, "list_type")

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

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

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

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

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


@pulumi.input_type
class DetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs:
    def __init__(__self__, *,
                 display_name: Optional[pulumi.Input[str]] = None,
                 entity_type: Optional[pulumi.Input[str]] = None,
                 query_field: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] display_name: (Updatable) Detector recipe display name.
               
               Avoid entering confidential information.
        :param pulumi.Input[str] entity_type: (Updatable) Possible type of entity
        :param pulumi.Input[str] query_field: (Updatable) The entity value mapped to a data source query
        """
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if entity_type is not None:
            pulumi.set(__self__, "entity_type", entity_type)
        if query_field is not None:
            pulumi.set(__self__, "query_field", query_field)

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) Detector recipe display name.

        Avoid entering confidential information.
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter(name="entityType")
    def entity_type(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) Possible type of entity
        """
        return pulumi.get(self, "entity_type")

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

    @property
    @pulumi.getter(name="queryField")
    def query_field(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The entity value mapped to a data source query
        """
        return pulumi.get(self, "query_field")

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


@pulumi.input_type
class ResponderRecipeEffectiveResponderRuleArgs:
    def __init__(__self__, *,
                 compartment_id: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 details: Optional[pulumi.Input[Sequence[pulumi.Input['ResponderRecipeEffectiveResponderRuleDetailArgs']]]] = None,
                 display_name: Optional[pulumi.Input[str]] = None,
                 lifecycle_details: Optional[pulumi.Input[str]] = None,
                 policies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 responder_rule_id: Optional[pulumi.Input[str]] = None,
                 state: Optional[pulumi.Input[str]] = None,
                 supported_modes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 time_created: Optional[pulumi.Input[str]] = None,
                 time_updated: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] compartment_id: (Updatable) Compartment Identifier
        :param pulumi.Input[str] description: (Updatable) Responder recipe description.
               
               Avoid entering confidential information.
        :param pulumi.Input[Sequence[pulumi.Input['ResponderRecipeEffectiveResponderRuleDetailArgs']]] details: (Updatable) Details of UpdateResponderRuleDetails.
        :param pulumi.Input[str] display_name: (Updatable) Responder recipe display name.
               
               Avoid entering confidential information.
        :param pulumi.Input[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 pulumi.Input[Sequence[pulumi.Input[str]]] policies: List of Policy
        :param pulumi.Input[str] responder_rule_id: (Updatable) ResponderRecipeRule Identifier
        :param pulumi.Input[str] state: The current state of the Example.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] supported_modes: Supported Execution Modes
        :param pulumi.Input[str] time_created: The date and time the responder recipe was created. Format defined by RFC3339.
        :param pulumi.Input[str] time_updated: The date and time the responder recipe was updated. Format defined by RFC3339.
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        (Updatable) Compartment Identifier
        """
        return pulumi.get(self, "compartment_id")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) Responder recipe description.

        Avoid entering confidential information.
        """
        return pulumi.get(self, "description")

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

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

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) Responder recipe display name.

        Avoid entering confidential information.
        """
        return pulumi.get(self, "display_name")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ResponderRecipeEffectiveResponderRuleDetailArgs:
    def __init__(__self__, *,
                 condition: Optional[pulumi.Input[str]] = None,
                 configurations: Optional[pulumi.Input[Sequence[pulumi.Input['ResponderRecipeEffectiveResponderRuleDetailConfigurationArgs']]]] = None,
                 is_enabled: Optional[pulumi.Input[bool]] = None,
                 mode: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] condition: Base condition object
        :param pulumi.Input[Sequence[pulumi.Input['ResponderRecipeEffectiveResponderRuleDetailConfigurationArgs']]] configurations: ResponderRule configurations
        :param pulumi.Input[bool] is_enabled: (Updatable) Identifies state for ResponderRule
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        Base condition object
        """
        return pulumi.get(self, "condition")

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

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

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

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

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

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

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


@pulumi.input_type
class ResponderRecipeEffectiveResponderRuleDetailConfigurationArgs:
    def __init__(__self__, *,
                 config_key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] config_key: Unique name of the configuration
        :param pulumi.Input[str] name: configuration name
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

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

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

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

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

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


@pulumi.input_type
class ResponderRecipeResponderRuleArgs:
    def __init__(__self__, *,
                 details: pulumi.Input['ResponderRecipeResponderRuleDetailsArgs'],
                 responder_rule_id: pulumi.Input[str],
                 compartment_id: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 display_name: Optional[pulumi.Input[str]] = None,
                 lifecycle_details: Optional[pulumi.Input[str]] = None,
                 policies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 state: Optional[pulumi.Input[str]] = None,
                 supported_modes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 time_created: Optional[pulumi.Input[str]] = None,
                 time_updated: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ResponderRecipeResponderRuleDetailsArgs'] details: (Updatable) Details of UpdateResponderRuleDetails.
        :param pulumi.Input[str] responder_rule_id: (Updatable) ResponderRecipeRule Identifier
        :param pulumi.Input[str] compartment_id: (Updatable) Compartment Identifier
        :param pulumi.Input[str] description: (Updatable) Responder recipe description.
               
               Avoid entering confidential information.
        :param pulumi.Input[str] display_name: (Updatable) Responder recipe display name.
               
               Avoid entering confidential information.
        :param pulumi.Input[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 pulumi.Input[Sequence[pulumi.Input[str]]] policies: List of Policy
        :param pulumi.Input[str] state: The current state of the Example.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] supported_modes: Supported Execution Modes
        :param pulumi.Input[str] time_created: The date and time the responder recipe was created. Format defined by RFC3339.
        :param pulumi.Input[str] time_updated: The date and time the responder recipe was updated. Format defined by RFC3339.
        :param pulumi.Input[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) -> pulumi.Input['ResponderRecipeResponderRuleDetailsArgs']:
        """
        (Updatable) Details of UpdateResponderRuleDetails.
        """
        return pulumi.get(self, "details")

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

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

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

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

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) Responder recipe description.

        Avoid entering confidential information.
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) Responder recipe display name.

        Avoid entering confidential information.
        """
        return pulumi.get(self, "display_name")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ResponderRecipeResponderRuleDetailsArgs:
    def __init__(__self__, *,
                 is_enabled: pulumi.Input[bool],
                 condition: Optional[pulumi.Input[str]] = None,
                 configurations: Optional[pulumi.Input[Sequence[pulumi.Input['ResponderRecipeResponderRuleDetailsConfigurationArgs']]]] = None,
                 mode: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] is_enabled: (Updatable) Identifies state for ResponderRule
        :param pulumi.Input[str] condition: Base condition object
        :param pulumi.Input[Sequence[pulumi.Input['ResponderRecipeResponderRuleDetailsConfigurationArgs']]] configurations: ResponderRule configurations
        :param pulumi.Input[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) -> pulumi.Input[bool]:
        """
        (Updatable) Identifies state for ResponderRule
        """
        return pulumi.get(self, "is_enabled")

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

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

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

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

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

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

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


@pulumi.input_type
class ResponderRecipeResponderRuleDetailsConfigurationArgs:
    def __init__(__self__, *,
                 config_key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] config_key: Unique name of the configuration
        :param pulumi.Input[str] name: configuration name
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

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

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

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

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

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


@pulumi.input_type
class TargetTargetDetailArgs:
    def __init__(__self__, *,
                 security_zone_display_name: Optional[pulumi.Input[str]] = None,
                 security_zone_id: Optional[pulumi.Input[str]] = None,
                 target_resource_type: Optional[pulumi.Input[str]] = None,
                 target_security_zone_recipes: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetailTargetSecurityZoneRecipeArgs']]]] = None):
        """
        :param pulumi.Input[str] security_zone_display_name: The name of the security zone to associate this compartment with.
        :param pulumi.Input[str] security_zone_id: The OCID of the security zone to associate this compartment with.
        :param pulumi.Input[str] target_resource_type: possible type of targets(COMPARTMENT/FACLOUD)
        :param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetailTargetSecurityZoneRecipeArgs']]] target_security_zone_recipes: The list of security zone recipes to associate this compartment with.
        """
        if security_zone_display_name is not None:
            pulumi.set(__self__, "security_zone_display_name", security_zone_display_name)
        if security_zone_id is not None:
            pulumi.set(__self__, "security_zone_id", security_zone_id)
        if target_resource_type is not None:
            pulumi.set(__self__, "target_resource_type", target_resource_type)
        if target_security_zone_recipes is not None:
            pulumi.set(__self__, "target_security_zone_recipes", target_security_zone_recipes)

    @property
    @pulumi.getter(name="securityZoneDisplayName")
    def security_zone_display_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the security zone to associate this compartment with.
        """
        return pulumi.get(self, "security_zone_display_name")

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

    @property
    @pulumi.getter(name="securityZoneId")
    def security_zone_id(self) -> Optional[pulumi.Input[str]]:
        """
        The OCID of the security zone to associate this compartment with.
        """
        return pulumi.get(self, "security_zone_id")

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

    @property
    @pulumi.getter(name="targetResourceType")
    def target_resource_type(self) -> Optional[pulumi.Input[str]]:
        """
        possible type of targets(COMPARTMENT/FACLOUD)
        """
        return pulumi.get(self, "target_resource_type")

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

    @property
    @pulumi.getter(name="targetSecurityZoneRecipes")
    def target_security_zone_recipes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetailTargetSecurityZoneRecipeArgs']]]]:
        """
        The list of security zone recipes to associate this compartment with.
        """
        return pulumi.get(self, "target_security_zone_recipes")

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


@pulumi.input_type
class TargetTargetDetailTargetSecurityZoneRecipeArgs:
    def __init__(__self__, *,
                 compartment_id: Optional[pulumi.Input[str]] = None,
                 defined_tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 display_name: Optional[pulumi.Input[str]] = None,
                 freeform_tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 id: Optional[pulumi.Input[str]] = None,
                 lifecycle_details: Optional[pulumi.Input[str]] = None,
                 owner: Optional[pulumi.Input[str]] = None,
                 security_policies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 state: Optional[pulumi.Input[str]] = None,
                 system_tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 time_created: Optional[pulumi.Input[str]] = None,
                 time_updated: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] compartment_id: (Updatable) compartment associated with condition
        :param pulumi.Input[Mapping[str, Any]] defined_tags: (Updatable) Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
        :param pulumi.Input[str] description: The target description.
               
               Avoid entering confidential information.
        :param pulumi.Input[str] display_name: (Updatable) DetectorTemplate identifier.
               
               Avoid entering confidential information.
        :param pulumi.Input[Mapping[str, Any]] freeform_tags: (Updatable) Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
               
               Avoid entering confidential information.
        :param pulumi.Input[str] id: Unique identifier of TargetResponderRecipe that can't be changed after creation.
        :param pulumi.Input[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 pulumi.Input[str] owner: Owner of ResponderRecipe
        :param pulumi.Input[Sequence[pulumi.Input[str]]] security_policies: The list of `SecurityPolicy` ids that are included in the recipe
        :param pulumi.Input[str] state: (Updatable) The current state of the DetectorRule.
        :param pulumi.Input[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 pulumi.Input[str] time_created: The date and time the target was created. Format defined by RFC3339.
        :param pulumi.Input[str] time_updated: The date and time the target was updated. Format defined by RFC3339.
        """
        if compartment_id is not None:
            pulumi.set(__self__, "compartment_id", compartment_id)
        if defined_tags is not None:
            pulumi.set(__self__, "defined_tags", defined_tags)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if freeform_tags is not None:
            pulumi.set(__self__, "freeform_tags", freeform_tags)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if lifecycle_details is not None:
            pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        if owner is not None:
            pulumi.set(__self__, "owner", owner)
        if security_policies is not None:
            pulumi.set(__self__, "security_policies", security_policies)
        if state is not None:
            pulumi.set(__self__, "state", state)
        if system_tags is not None:
            pulumi.set(__self__, "system_tags", system_tags)
        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="compartmentId")
    def compartment_id(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) compartment associated with condition
        """
        return pulumi.get(self, "compartment_id")

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

    @property
    @pulumi.getter(name="definedTags")
    def defined_tags(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        (Updatable) 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")

    @defined_tags.setter
    def defined_tags(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "defined_tags", value)

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

        Avoid entering confidential information.
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) DetectorTemplate identifier.

        Avoid entering confidential information.
        """
        return pulumi.get(self, "display_name")

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

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

        Avoid entering confidential information.
        """
        return pulumi.get(self, "freeform_tags")

    @freeform_tags.setter
    def freeform_tags(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "freeform_tags", value)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[str]]:
        """
        Unique identifier of TargetResponderRecipe that can't be changed after creation.
        """
        return pulumi.get(self, "id")

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

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

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

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

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

    @property
    @pulumi.getter(name="securityPolicies")
    def security_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The list of `SecurityPolicy` ids that are included in the recipe
        """
        return pulumi.get(self, "security_policies")

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

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

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

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

    @system_tags.setter
    def system_tags(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "system_tags", value)

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

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

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

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


@pulumi.input_type
class TargetTargetDetectorRecipeArgs:
    def __init__(__self__, *,
                 detector_recipe_id: pulumi.Input[str],
                 compartment_id: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 detector: Optional[pulumi.Input[str]] = None,
                 detector_rules: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleArgs']]]] = None,
                 display_name: Optional[pulumi.Input[str]] = None,
                 effective_detector_rules: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleArgs']]]] = None,
                 id: Optional[pulumi.Input[str]] = None,
                 owner: Optional[pulumi.Input[str]] = None,
                 state: Optional[pulumi.Input[str]] = None,
                 time_created: Optional[pulumi.Input[str]] = None,
                 time_updated: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] detector_recipe_id: Identifier for DetectorRecipe.
        :param pulumi.Input[str] compartment_id: (Updatable) compartment associated with condition
        :param pulumi.Input[str] description: The target description.
               
               Avoid entering confidential information.
        :param pulumi.Input[str] detector: detector for the rule
        :param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleArgs']]] detector_rules: (Updatable) Overrides to be applied to Detector Rule associated with the target
        :param pulumi.Input[str] display_name: (Updatable) DetectorTemplate identifier.
               
               Avoid entering confidential information.
        :param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleArgs']]] effective_detector_rules: List of effective detector rules for the detector type for recipe after applying defaults
        :param pulumi.Input[str] id: Unique identifier of TargetResponderRecipe that can't be changed after creation.
        :param pulumi.Input[str] owner: Owner of ResponderRecipe
        :param pulumi.Input[str] state: (Updatable) The current state of the DetectorRule.
        :param pulumi.Input[str] time_created: The date and time the target was created. Format defined by RFC3339.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        Identifier for DetectorRecipe.
        """
        return pulumi.get(self, "detector_recipe_id")

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

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

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

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

        Avoid entering confidential information.
        """
        return pulumi.get(self, "description")

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

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

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

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

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) DetectorTemplate identifier.

        Avoid entering confidential information.
        """
        return pulumi.get(self, "display_name")

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

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

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

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[str]]:
        """
        Unique identifier of TargetResponderRecipe that can't be changed after creation.
        """
        return pulumi.get(self, "id")

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class TargetTargetDetectorRecipeDetectorRuleArgs:
    def __init__(__self__, *,
                 details: pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsArgs'],
                 detector_rule_id: pulumi.Input[str],
                 data_source_id: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 detector: Optional[pulumi.Input[str]] = None,
                 display_name: Optional[pulumi.Input[str]] = None,
                 entities_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleEntitiesMappingArgs']]]] = None,
                 lifecycle_details: Optional[pulumi.Input[str]] = None,
                 managed_list_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 recommendation: Optional[pulumi.Input[str]] = None,
                 resource_type: Optional[pulumi.Input[str]] = None,
                 service_type: Optional[pulumi.Input[str]] = None,
                 state: Optional[pulumi.Input[str]] = None,
                 time_created: Optional[pulumi.Input[str]] = None,
                 time_updated: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsArgs'] details: (Updatable) Details of ResponderRule.
        :param pulumi.Input[str] detector_rule_id: (Updatable) Identifier for DetectorRule.
        :param pulumi.Input[str] data_source_id: The id of the attached DataSource.
        :param pulumi.Input[str] description: The target description.
               
               Avoid entering confidential information.
        :param pulumi.Input[str] detector: detector for the rule
        :param pulumi.Input[str] display_name: (Updatable) DetectorTemplate identifier.
               
               Avoid entering confidential information.
        :param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleEntitiesMappingArgs']]] entities_mappings: Data Source entities mapping for a Detector Rule
        :param pulumi.Input[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 pulumi.Input[Sequence[pulumi.Input[str]]] managed_list_types: List of cloudguard managed list types related to this rule
        :param pulumi.Input[str] recommendation: Recommendation for TargetDetectorRecipeDetectorRule
        :param pulumi.Input[str] resource_type: resource type of the configuration to which the rule is applied
        :param pulumi.Input[str] service_type: service type of the configuration to which the rule is applied
        :param pulumi.Input[str] state: (Updatable) The current state of the DetectorRule.
        :param pulumi.Input[str] time_created: The date and time the target was created. Format defined by RFC3339.
        :param pulumi.Input[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 data_source_id is not None:
            pulumi.set(__self__, "data_source_id", data_source_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 entities_mappings is not None:
            pulumi.set(__self__, "entities_mappings", entities_mappings)
        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) -> pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsArgs']:
        """
        (Updatable) Details of ResponderRule.
        """
        return pulumi.get(self, "details")

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

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

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

    @property
    @pulumi.getter(name="dataSourceId")
    def data_source_id(self) -> Optional[pulumi.Input[str]]:
        """
        The id of the attached DataSource.
        """
        return pulumi.get(self, "data_source_id")

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

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

        Avoid entering confidential information.
        """
        return pulumi.get(self, "description")

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

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

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) DetectorTemplate identifier.

        Avoid entering confidential information.
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter(name="entitiesMappings")
    def entities_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleEntitiesMappingArgs']]]]:
        """
        Data Source entities mapping for a Detector Rule
        """
        return pulumi.get(self, "entities_mappings")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class TargetTargetDetectorRecipeDetectorRuleDetailsArgs:
    def __init__(__self__, *,
                 condition_groups: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroupArgs']]]] = None,
                 configurations: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationArgs']]]] = None,
                 is_configuration_allowed: Optional[pulumi.Input[bool]] = None,
                 is_enabled: Optional[pulumi.Input[bool]] = None,
                 labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 risk_level: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroupArgs']]] condition_groups: (Updatable) Condition group corresponding to each compartment
        :param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationArgs']]] configurations: (Updatable) Configurations associated with the ResponderRule
        :param pulumi.Input[bool] is_configuration_allowed: configuration allowed or not
        :param pulumi.Input[bool] is_enabled: Identifies state for ResponderRule
        :param pulumi.Input[Sequence[pulumi.Input[str]]] labels: user defined labels for a detector rule
        :param pulumi.Input[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[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroupArgs']]]]:
        """
        (Updatable) Condition group corresponding to each compartment
        """
        return pulumi.get(self, "condition_groups")

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroupArgs:
    def __init__(__self__, *,
                 compartment_id: pulumi.Input[str],
                 condition: pulumi.Input[str]):
        """
        :param pulumi.Input[str] compartment_id: (Updatable) compartment associated with condition
        :param pulumi.Input[str] condition: (Updatable) Base condition object
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "condition", condition)

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

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

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

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


@pulumi.input_type
class TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationArgs:
    def __init__(__self__, *,
                 config_key: Optional[pulumi.Input[str]] = None,
                 data_type: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None,
                 values: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueArgs']]]] = None):
        """
        :param pulumi.Input[str] config_key: (Updatable) Unique name of the configuration
        :param pulumi.Input[str] data_type: configuration data type
        :param pulumi.Input[str] name: (Updatable) configuration name
        :param pulumi.Input[str] value: (Updatable) configuration value
        :param pulumi.Input[Sequence[pulumi.Input['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[pulumi.Input[str]]:
        """
        (Updatable) Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueArgs:
    def __init__(__self__, *,
                 list_type: Optional[pulumi.Input[str]] = None,
                 managed_list_type: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] list_type: configuration list item type, either CUSTOM or MANAGED
        :param pulumi.Input[str] managed_list_type: type of the managed list
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        configuration list item type, either CUSTOM or MANAGED
        """
        return pulumi.get(self, "list_type")

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

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

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

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

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


@pulumi.input_type
class TargetTargetDetectorRecipeDetectorRuleEntitiesMappingArgs:
    def __init__(__self__, *,
                 display_name: Optional[pulumi.Input[str]] = None,
                 entity_type: Optional[pulumi.Input[str]] = None,
                 query_field: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] display_name: (Updatable) DetectorTemplate identifier.
               
               Avoid entering confidential information.
        :param pulumi.Input[str] entity_type: Possible type of entity
        :param pulumi.Input[str] query_field: The entity value mapped to a data source query
        """
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if entity_type is not None:
            pulumi.set(__self__, "entity_type", entity_type)
        if query_field is not None:
            pulumi.set(__self__, "query_field", query_field)

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) DetectorTemplate identifier.

        Avoid entering confidential information.
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter(name="entityType")
    def entity_type(self) -> Optional[pulumi.Input[str]]:
        """
        Possible type of entity
        """
        return pulumi.get(self, "entity_type")

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

    @property
    @pulumi.getter(name="queryField")
    def query_field(self) -> Optional[pulumi.Input[str]]:
        """
        The entity value mapped to a data source query
        """
        return pulumi.get(self, "query_field")

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


@pulumi.input_type
class TargetTargetDetectorRecipeEffectiveDetectorRuleArgs:
    def __init__(__self__, *,
                 data_source_id: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 details: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailArgs']]]] = None,
                 detector: Optional[pulumi.Input[str]] = None,
                 detector_rule_id: Optional[pulumi.Input[str]] = None,
                 display_name: Optional[pulumi.Input[str]] = None,
                 entities_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs']]]] = None,
                 lifecycle_details: Optional[pulumi.Input[str]] = None,
                 managed_list_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 recommendation: Optional[pulumi.Input[str]] = None,
                 resource_type: Optional[pulumi.Input[str]] = None,
                 service_type: Optional[pulumi.Input[str]] = None,
                 state: Optional[pulumi.Input[str]] = None,
                 time_created: Optional[pulumi.Input[str]] = None,
                 time_updated: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] data_source_id: The id of the attached DataSource.
        :param pulumi.Input[str] description: The target description.
               
               Avoid entering confidential information.
        :param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailArgs']]] details: (Updatable) Details of ResponderRule.
        :param pulumi.Input[str] detector: detector for the rule
        :param pulumi.Input[str] detector_rule_id: (Updatable) Identifier for DetectorRule.
        :param pulumi.Input[str] display_name: (Updatable) DetectorTemplate identifier.
               
               Avoid entering confidential information.
        :param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs']]] entities_mappings: Data Source entities mapping for a Detector Rule
        :param pulumi.Input[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 pulumi.Input[Sequence[pulumi.Input[str]]] managed_list_types: List of cloudguard managed list types related to this rule
        :param pulumi.Input[str] recommendation: Recommendation for TargetDetectorRecipeDetectorRule
        :param pulumi.Input[str] resource_type: resource type of the configuration to which the rule is applied
        :param pulumi.Input[str] service_type: service type of the configuration to which the rule is applied
        :param pulumi.Input[str] state: (Updatable) The current state of the DetectorRule.
        :param pulumi.Input[str] time_created: The date and time the target was created. Format defined by RFC3339.
        :param pulumi.Input[str] time_updated: The date and time the target was updated. Format defined by RFC3339.
        """
        if data_source_id is not None:
            pulumi.set(__self__, "data_source_id", data_source_id)
        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 entities_mappings is not None:
            pulumi.set(__self__, "entities_mappings", entities_mappings)
        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="dataSourceId")
    def data_source_id(self) -> Optional[pulumi.Input[str]]:
        """
        The id of the attached DataSource.
        """
        return pulumi.get(self, "data_source_id")

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

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

        Avoid entering confidential information.
        """
        return pulumi.get(self, "description")

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) DetectorTemplate identifier.

        Avoid entering confidential information.
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter(name="entitiesMappings")
    def entities_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs']]]]:
        """
        Data Source entities mapping for a Detector Rule
        """
        return pulumi.get(self, "entities_mappings")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailArgs:
    def __init__(__self__, *,
                 condition_groups: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConditionGroupArgs']]]] = None,
                 configurations: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs']]]] = None,
                 is_configuration_allowed: Optional[pulumi.Input[bool]] = None,
                 is_enabled: Optional[pulumi.Input[bool]] = None,
                 labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 risk_level: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConditionGroupArgs']]] condition_groups: (Updatable) Condition group corresponding to each compartment
        :param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs']]] configurations: (Updatable) Configurations associated with the ResponderRule
        :param pulumi.Input[bool] is_configuration_allowed: configuration allowed or not
        :param pulumi.Input[bool] is_enabled: Identifies state for ResponderRule
        :param pulumi.Input[Sequence[pulumi.Input[str]]] labels: user defined labels for a detector rule
        :param pulumi.Input[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[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConditionGroupArgs']]]]:
        """
        (Updatable) Condition group corresponding to each compartment
        """
        return pulumi.get(self, "condition_groups")

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConditionGroupArgs:
    def __init__(__self__, *,
                 compartment_id: Optional[pulumi.Input[str]] = None,
                 condition: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] compartment_id: (Updatable) compartment associated with condition
        :param pulumi.Input[str] condition: (Updatable) Base condition object
        """
        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[pulumi.Input[str]]:
        """
        (Updatable) compartment associated with condition
        """
        return pulumi.get(self, "compartment_id")

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

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

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


@pulumi.input_type
class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs:
    def __init__(__self__, *,
                 config_key: Optional[pulumi.Input[str]] = None,
                 data_type: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None,
                 values: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs']]]] = None):
        """
        :param pulumi.Input[str] config_key: (Updatable) Unique name of the configuration
        :param pulumi.Input[str] data_type: configuration data type
        :param pulumi.Input[str] name: (Updatable) configuration name
        :param pulumi.Input[str] value: (Updatable) configuration value
        :param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs']]] 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[pulumi.Input[str]]:
        """
        (Updatable) Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs:
    def __init__(__self__, *,
                 list_type: Optional[pulumi.Input[str]] = None,
                 managed_list_type: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] list_type: configuration list item type, either CUSTOM or MANAGED
        :param pulumi.Input[str] managed_list_type: type of the managed list
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        configuration list item type, either CUSTOM or MANAGED
        """
        return pulumi.get(self, "list_type")

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

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

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

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

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


@pulumi.input_type
class TargetTargetDetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs:
    def __init__(__self__, *,
                 display_name: Optional[pulumi.Input[str]] = None,
                 entity_type: Optional[pulumi.Input[str]] = None,
                 query_field: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] display_name: (Updatable) DetectorTemplate identifier.
               
               Avoid entering confidential information.
        :param pulumi.Input[str] entity_type: Possible type of entity
        :param pulumi.Input[str] query_field: The entity value mapped to a data source query
        """
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if entity_type is not None:
            pulumi.set(__self__, "entity_type", entity_type)
        if query_field is not None:
            pulumi.set(__self__, "query_field", query_field)

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) DetectorTemplate identifier.

        Avoid entering confidential information.
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter(name="entityType")
    def entity_type(self) -> Optional[pulumi.Input[str]]:
        """
        Possible type of entity
        """
        return pulumi.get(self, "entity_type")

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

    @property
    @pulumi.getter(name="queryField")
    def query_field(self) -> Optional[pulumi.Input[str]]:
        """
        The entity value mapped to a data source query
        """
        return pulumi.get(self, "query_field")

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


@pulumi.input_type
class TargetTargetResponderRecipeArgs:
    def __init__(__self__, *,
                 responder_recipe_id: pulumi.Input[str],
                 compartment_id: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 display_name: Optional[pulumi.Input[str]] = None,
                 effective_responder_rules: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetResponderRecipeEffectiveResponderRuleArgs']]]] = None,
                 id: Optional[pulumi.Input[str]] = None,
                 owner: Optional[pulumi.Input[str]] = None,
                 responder_rules: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetResponderRecipeResponderRuleArgs']]]] = None,
                 time_created: Optional[pulumi.Input[str]] = None,
                 time_updated: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] responder_recipe_id: Identifier for ResponderRecipe.
        :param pulumi.Input[str] compartment_id: (Updatable) compartment associated with condition
        :param pulumi.Input[str] description: The target description.
               
               Avoid entering confidential information.
        :param pulumi.Input[str] display_name: (Updatable) DetectorTemplate identifier.
               
               Avoid entering confidential information.
        :param pulumi.Input[Sequence[pulumi.Input['TargetTargetResponderRecipeEffectiveResponderRuleArgs']]] effective_responder_rules: List of responder rules associated with the recipe after applying all defaults
        :param pulumi.Input[str] id: Unique identifier of TargetResponderRecipe that can't be changed after creation.
        :param pulumi.Input[str] owner: Owner of ResponderRecipe
        :param pulumi.Input[Sequence[pulumi.Input['TargetTargetResponderRecipeResponderRuleArgs']]] responder_rules: (Updatable) Override responder rules associated with reponder recipe in a target.
        :param pulumi.Input[str] time_created: The date and time the target was created. Format defined by RFC3339.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        Identifier for ResponderRecipe.
        """
        return pulumi.get(self, "responder_recipe_id")

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

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

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

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

        Avoid entering confidential information.
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) DetectorTemplate identifier.

        Avoid entering confidential information.
        """
        return pulumi.get(self, "display_name")

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

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

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

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[str]]:
        """
        Unique identifier of TargetResponderRecipe that can't be changed after creation.
        """
        return pulumi.get(self, "id")

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class TargetTargetResponderRecipeEffectiveResponderRuleArgs:
    def __init__(__self__, *,
                 compartment_id: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 details: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetResponderRecipeEffectiveResponderRuleDetailArgs']]]] = None,
                 display_name: Optional[pulumi.Input[str]] = None,
                 lifecycle_details: Optional[pulumi.Input[str]] = None,
                 policies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 responder_rule_id: Optional[pulumi.Input[str]] = None,
                 state: Optional[pulumi.Input[str]] = None,
                 supported_modes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 time_created: Optional[pulumi.Input[str]] = None,
                 time_updated: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] compartment_id: (Updatable) compartment associated with condition
        :param pulumi.Input[str] description: The target description.
               
               Avoid entering confidential information.
        :param pulumi.Input[Sequence[pulumi.Input['TargetTargetResponderRecipeEffectiveResponderRuleDetailArgs']]] details: (Updatable) Details of ResponderRule.
        :param pulumi.Input[str] display_name: (Updatable) DetectorTemplate identifier.
               
               Avoid entering confidential information.
        :param pulumi.Input[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 pulumi.Input[Sequence[pulumi.Input[str]]] policies: List of Policy
        :param pulumi.Input[str] responder_rule_id: (Updatable) Identifier for ResponderRule.
               
               
               ** IMPORTANT **
               Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
        :param pulumi.Input[str] state: (Updatable) The current state of the DetectorRule.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] supported_modes: Supported Execution Modes
        :param pulumi.Input[str] time_created: The date and time the target was created. Format defined by RFC3339.
        :param pulumi.Input[str] time_updated: The date and time the target was updated. Format defined by RFC3339.
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        (Updatable) compartment associated with condition
        """
        return pulumi.get(self, "compartment_id")

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

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

        Avoid entering confidential information.
        """
        return pulumi.get(self, "description")

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

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

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) DetectorTemplate identifier.

        Avoid entering confidential information.
        """
        return pulumi.get(self, "display_name")

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

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

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

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

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

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


        ** IMPORTANT **
        Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
        """
        return pulumi.get(self, "responder_rule_id")

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class TargetTargetResponderRecipeEffectiveResponderRuleDetailArgs:
    def __init__(__self__, *,
                 condition: Optional[pulumi.Input[str]] = None,
                 configurations: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetResponderRecipeEffectiveResponderRuleDetailConfigurationArgs']]]] = None,
                 is_enabled: Optional[pulumi.Input[bool]] = None,
                 mode: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] condition: (Updatable) Base condition object
        :param pulumi.Input[Sequence[pulumi.Input['TargetTargetResponderRecipeEffectiveResponderRuleDetailConfigurationArgs']]] configurations: (Updatable) Configurations associated with the ResponderRule
        :param pulumi.Input[bool] is_enabled: Identifies state for ResponderRule
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        (Updatable) Base condition object
        """
        return pulumi.get(self, "condition")

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

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

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

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

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

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

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


@pulumi.input_type
class TargetTargetResponderRecipeEffectiveResponderRuleDetailConfigurationArgs:
    def __init__(__self__, *,
                 config_key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] config_key: (Updatable) Unique name of the configuration
        :param pulumi.Input[str] name: (Updatable) configuration name
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        (Updatable) Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

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

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

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

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

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


@pulumi.input_type
class TargetTargetResponderRecipeResponderRuleArgs:
    def __init__(__self__, *,
                 details: pulumi.Input['TargetTargetResponderRecipeResponderRuleDetailsArgs'],
                 responder_rule_id: pulumi.Input[str],
                 compartment_id: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 display_name: Optional[pulumi.Input[str]] = None,
                 lifecycle_details: Optional[pulumi.Input[str]] = None,
                 policies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 state: Optional[pulumi.Input[str]] = None,
                 supported_modes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 time_created: Optional[pulumi.Input[str]] = None,
                 time_updated: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['TargetTargetResponderRecipeResponderRuleDetailsArgs'] details: (Updatable) Details of ResponderRule.
        :param pulumi.Input[str] responder_rule_id: (Updatable) Identifier for ResponderRule.
               
               
               ** IMPORTANT **
               Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
        :param pulumi.Input[str] compartment_id: (Updatable) compartment associated with condition
        :param pulumi.Input[str] description: The target description.
               
               Avoid entering confidential information.
        :param pulumi.Input[str] display_name: (Updatable) DetectorTemplate identifier.
               
               Avoid entering confidential information.
        :param pulumi.Input[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 pulumi.Input[Sequence[pulumi.Input[str]]] policies: List of Policy
        :param pulumi.Input[str] state: (Updatable) The current state of the DetectorRule.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] supported_modes: Supported Execution Modes
        :param pulumi.Input[str] time_created: The date and time the target was created. Format defined by RFC3339.
        :param pulumi.Input[str] time_updated: The date and time the target was updated. Format defined by RFC3339.
        :param pulumi.Input[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) -> pulumi.Input['TargetTargetResponderRecipeResponderRuleDetailsArgs']:
        """
        (Updatable) Details of ResponderRule.
        """
        return pulumi.get(self, "details")

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

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


        ** IMPORTANT **
        Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
        """
        return pulumi.get(self, "responder_rule_id")

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

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

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

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

        Avoid entering confidential information.
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) DetectorTemplate identifier.

        Avoid entering confidential information.
        """
        return pulumi.get(self, "display_name")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class TargetTargetResponderRecipeResponderRuleDetailsArgs:
    def __init__(__self__, *,
                 condition: Optional[pulumi.Input[str]] = None,
                 configurations: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetResponderRecipeResponderRuleDetailsConfigurationArgs']]]] = None,
                 is_enabled: Optional[pulumi.Input[bool]] = None,
                 mode: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] condition: (Updatable) Base condition object
        :param pulumi.Input[Sequence[pulumi.Input['TargetTargetResponderRecipeResponderRuleDetailsConfigurationArgs']]] configurations: (Updatable) Configurations associated with the ResponderRule
        :param pulumi.Input[bool] is_enabled: Identifies state for ResponderRule
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        (Updatable) Base condition object
        """
        return pulumi.get(self, "condition")

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

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

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

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

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

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

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


@pulumi.input_type
class TargetTargetResponderRecipeResponderRuleDetailsConfigurationArgs:
    def __init__(__self__, *,
                 config_key: pulumi.Input[str],
                 name: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] config_key: (Updatable) Unique name of the configuration
        :param pulumi.Input[str] name: (Updatable) configuration name
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        (Updatable) Unique name of the configuration
        """
        return pulumi.get(self, "config_key")

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

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

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

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

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


@pulumi.input_type
class GetDataMaskRulesFilterArgs:
    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")

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

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

    @values.setter
    def values(self, value: Sequence[str]):
        pulumi.set(self, "values", value)

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

    @regex.setter
    def regex(self, value: Optional[bool]):
        pulumi.set(self, "regex", value)


@pulumi.input_type
class GetDataSourceEventsFilterArgs:
    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")

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

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

    @values.setter
    def values(self, value: Sequence[str]):
        pulumi.set(self, "values", value)

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

    @regex.setter
    def regex(self, value: Optional[bool]):
        pulumi.set(self, "regex", value)


@pulumi.input_type
class GetDataSourcesFilterArgs:
    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")

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

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

    @values.setter
    def values(self, value: Sequence[str]):
        pulumi.set(self, "values", value)

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

    @regex.setter
    def regex(self, value: Optional[bool]):
        pulumi.set(self, "regex", value)


@pulumi.input_type
class GetDetectorRecipesFilterArgs:
    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")

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

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

    @values.setter
    def values(self, value: Sequence[str]):
        pulumi.set(self, "values", value)

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

    @regex.setter
    def regex(self, value: Optional[bool]):
        pulumi.set(self, "regex", value)


@pulumi.input_type
class GetGuardTargetsFilterArgs:
    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")

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

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

    @values.setter
    def values(self, value: Sequence[str]):
        pulumi.set(self, "values", value)

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

    @regex.setter
    def regex(self, value: Optional[bool]):
        pulumi.set(self, "regex", value)


@pulumi.input_type
class GetManagedListsFilterArgs:
    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")

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

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

    @values.setter
    def values(self, value: Sequence[str]):
        pulumi.set(self, "values", value)

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

    @regex.setter
    def regex(self, value: Optional[bool]):
        pulumi.set(self, "regex", value)


@pulumi.input_type
class GetProblemEntitiesFilterArgs:
    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")

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

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

    @values.setter
    def values(self, value: Sequence[str]):
        pulumi.set(self, "values", value)

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

    @regex.setter
    def regex(self, value: Optional[bool]):
        pulumi.set(self, "regex", value)


@pulumi.input_type
class GetResponderRecipesFilterArgs:
    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")

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

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

    @values.setter
    def values(self, value: Sequence[str]):
        pulumi.set(self, "values", value)

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

    @regex.setter
    def regex(self, value: Optional[bool]):
        pulumi.set(self, "regex", value)


@pulumi.input_type
class GetSecurityPoliciesFilterArgs:
    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")

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

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

    @values.setter
    def values(self, value: Sequence[str]):
        pulumi.set(self, "values", value)

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

    @regex.setter
    def regex(self, value: Optional[bool]):
        pulumi.set(self, "regex", value)


@pulumi.input_type
class GetSecurityRecipesFilterArgs:
    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")

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

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

    @values.setter
    def values(self, value: Sequence[str]):
        pulumi.set(self, "values", value)

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

    @regex.setter
    def regex(self, value: Optional[bool]):
        pulumi.set(self, "regex", value)


@pulumi.input_type
class GetSecurityZonesFilterArgs:
    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")

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

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

    @values.setter
    def values(self, value: Sequence[str]):
        pulumi.set(self, "values", value)

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

    @regex.setter
    def regex(self, value: Optional[bool]):
        pulumi.set(self, "regex", value)


