pulumi-oci 2.11.0a1726768847__py3-none-any.whl → 2.12.0__py3-none-any.whl

pulumi_oci/cloudguard/_inputs.py

@@ -4,80 +4,166 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
 
 __all__ = [
     'AdhocQueryAdhocQueryDetailsArgs',
+    'AdhocQueryAdhocQueryDetailsArgsDict',
     'AdhocQueryAdhocQueryDetailsAdhocQueryResourceArgs',
+    'AdhocQueryAdhocQueryDetailsAdhocQueryResourceArgsDict',
     'AdhocQueryAdhocQueryRegionalDetailArgs',
+    'AdhocQueryAdhocQueryRegionalDetailArgsDict',
     'CloudGuardDataSourceDataSourceDetailsArgs',
+    'CloudGuardDataSourceDataSourceDetailsArgsDict',
     'CloudGuardDataSourceDataSourceDetailsLoggingQueryDetailsArgs',
+    'CloudGuardDataSourceDataSourceDetailsLoggingQueryDetailsArgsDict',
     'CloudGuardDataSourceDataSourceDetailsQueryStartTimeArgs',
+    'CloudGuardDataSourceDataSourceDetailsQueryStartTimeArgsDict',
     'CloudGuardDataSourceDataSourceDetailsScheduledQueryScopeDetailArgs',
+    'CloudGuardDataSourceDataSourceDetailsScheduledQueryScopeDetailArgsDict',
     'CloudGuardDataSourceDataSourceDetectorMappingInfoArgs',
+    'CloudGuardDataSourceDataSourceDetectorMappingInfoArgsDict',
     'CloudGuardDataSourceRegionStatusDetailArgs',
+    'CloudGuardDataSourceRegionStatusDetailArgsDict',
     'DataMaskRuleTargetSelectedArgs',
+    'DataMaskRuleTargetSelectedArgsDict',
     'DetectorRecipeDetectorRuleArgs',
+    'DetectorRecipeDetectorRuleArgsDict',
     'DetectorRecipeDetectorRuleCandidateResponderRuleArgs',
+    'DetectorRecipeDetectorRuleCandidateResponderRuleArgsDict',
     'DetectorRecipeDetectorRuleDetailsArgs',
+    'DetectorRecipeDetectorRuleDetailsArgsDict',
     'DetectorRecipeDetectorRuleDetailsConfigurationArgs',
+    'DetectorRecipeDetectorRuleDetailsConfigurationArgsDict',
     'DetectorRecipeDetectorRuleDetailsConfigurationValueArgs',
+    'DetectorRecipeDetectorRuleDetailsConfigurationValueArgsDict',
     'DetectorRecipeDetectorRuleDetailsEntitiesMappingArgs',
+    'DetectorRecipeDetectorRuleDetailsEntitiesMappingArgsDict',
     'DetectorRecipeDetectorRuleEntitiesMappingArgs',
+    'DetectorRecipeDetectorRuleEntitiesMappingArgsDict',
     'DetectorRecipeEffectiveDetectorRuleArgs',
+    'DetectorRecipeEffectiveDetectorRuleArgsDict',
     'DetectorRecipeEffectiveDetectorRuleCandidateResponderRuleArgs',
+    'DetectorRecipeEffectiveDetectorRuleCandidateResponderRuleArgsDict',
     'DetectorRecipeEffectiveDetectorRuleDetailArgs',
+    'DetectorRecipeEffectiveDetectorRuleDetailArgsDict',
     'DetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs',
+    'DetectorRecipeEffectiveDetectorRuleDetailConfigurationArgsDict',
     'DetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs',
+    'DetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgsDict',
     'DetectorRecipeEffectiveDetectorRuleDetailEntitiesMappingArgs',
+    'DetectorRecipeEffectiveDetectorRuleDetailEntitiesMappingArgsDict',
     'DetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs',
+    'DetectorRecipeEffectiveDetectorRuleEntitiesMappingArgsDict',
     'ResponderRecipeEffectiveResponderRuleArgs',
+    'ResponderRecipeEffectiveResponderRuleArgsDict',
     'ResponderRecipeEffectiveResponderRuleDetailArgs',
+    'ResponderRecipeEffectiveResponderRuleDetailArgsDict',
     'ResponderRecipeEffectiveResponderRuleDetailConfigurationArgs',
+    'ResponderRecipeEffectiveResponderRuleDetailConfigurationArgsDict',
     'ResponderRecipeResponderRuleArgs',
+    'ResponderRecipeResponderRuleArgsDict',
     'ResponderRecipeResponderRuleDetailsArgs',
+    'ResponderRecipeResponderRuleDetailsArgsDict',
     'ResponderRecipeResponderRuleDetailsConfigurationArgs',
+    'ResponderRecipeResponderRuleDetailsConfigurationArgsDict',
     'TargetTargetDetailArgs',
+    'TargetTargetDetailArgsDict',
     'TargetTargetDetailTargetSecurityZoneRecipeArgs',
+    'TargetTargetDetailTargetSecurityZoneRecipeArgsDict',
     'TargetTargetDetectorRecipeArgs',
+    'TargetTargetDetectorRecipeArgsDict',
     'TargetTargetDetectorRecipeDetectorRuleArgs',
+    'TargetTargetDetectorRecipeDetectorRuleArgsDict',
     'TargetTargetDetectorRecipeDetectorRuleDetailsArgs',
+    'TargetTargetDetectorRecipeDetectorRuleDetailsArgsDict',
     'TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroupArgs',
+    'TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroupArgsDict',
     'TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationArgs',
+    'TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationArgsDict',
     'TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueArgs',
+    'TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueArgsDict',
     'TargetTargetDetectorRecipeDetectorRuleEntitiesMappingArgs',
+    'TargetTargetDetectorRecipeDetectorRuleEntitiesMappingArgsDict',
     'TargetTargetDetectorRecipeEffectiveDetectorRuleArgs',
+    'TargetTargetDetectorRecipeEffectiveDetectorRuleArgsDict',
     'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailArgs',
+    'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailArgsDict',
     'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConditionGroupArgs',
+    'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConditionGroupArgsDict',
     'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs',
+    'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationArgsDict',
     'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs',
+    'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgsDict',
     'TargetTargetDetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs',
+    'TargetTargetDetectorRecipeEffectiveDetectorRuleEntitiesMappingArgsDict',
     'TargetTargetResponderRecipeArgs',
+    'TargetTargetResponderRecipeArgsDict',
     'TargetTargetResponderRecipeEffectiveResponderRuleArgs',
+    'TargetTargetResponderRecipeEffectiveResponderRuleArgsDict',
     'TargetTargetResponderRecipeEffectiveResponderRuleDetailArgs',
+    'TargetTargetResponderRecipeEffectiveResponderRuleDetailArgsDict',
     'TargetTargetResponderRecipeEffectiveResponderRuleDetailConfigurationArgs',
+    'TargetTargetResponderRecipeEffectiveResponderRuleDetailConfigurationArgsDict',
     'TargetTargetResponderRecipeResponderRuleArgs',
+    'TargetTargetResponderRecipeResponderRuleArgsDict',
     'TargetTargetResponderRecipeResponderRuleDetailsArgs',
+    'TargetTargetResponderRecipeResponderRuleDetailsArgsDict',
     'TargetTargetResponderRecipeResponderRuleDetailsConfigurationArgs',
+    'TargetTargetResponderRecipeResponderRuleDetailsConfigurationArgsDict',
     'GetAdhocQueriesFilterArgs',
+    'GetAdhocQueriesFilterArgsDict',
     'GetDataMaskRulesFilterArgs',
+    'GetDataMaskRulesFilterArgsDict',
     'GetDataSourceEventsFilterArgs',
+    'GetDataSourceEventsFilterArgsDict',
     'GetDataSourcesFilterArgs',
+    'GetDataSourcesFilterArgsDict',
     'GetDetectorRecipesFilterArgs',
+    'GetDetectorRecipesFilterArgsDict',
     'GetGuardTargetsFilterArgs',
+    'GetGuardTargetsFilterArgsDict',
     'GetManagedListsFilterArgs',
+    'GetManagedListsFilterArgsDict',
     'GetProblemEntitiesFilterArgs',
+    'GetProblemEntitiesFilterArgsDict',
     'GetResponderRecipesFilterArgs',
+    'GetResponderRecipesFilterArgsDict',
     'GetSavedQueriesFilterArgs',
+    'GetSavedQueriesFilterArgsDict',
     'GetSecurityPoliciesFilterArgs',
+    'GetSecurityPoliciesFilterArgsDict',
     'GetSecurityRecipesFilterArgs',
+    'GetSecurityRecipesFilterArgsDict',
     'GetSecurityZonesFilterArgs',
+    'GetSecurityZonesFilterArgsDict',
     'GetWlpAgentsFilterArgs',
+    'GetWlpAgentsFilterArgsDict',
 ]
 
+MYPY = False
+
+if not MYPY:
+    class AdhocQueryAdhocQueryDetailsArgsDict(TypedDict):
+        adhoc_query_resources: pulumi.Input[Sequence[pulumi.Input['AdhocQueryAdhocQueryDetailsAdhocQueryResourceArgsDict']]]
+        """
+        Target information in which adhoc query will be run
+        """
+        query: pulumi.Input[str]
+        """
+        The adhoc query expression that is run
+        """
+elif False:
+    AdhocQueryAdhocQueryDetailsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AdhocQueryAdhocQueryDetailsArgs:
     def __init__(__self__, *,
@@ -115,6 +201,23 @@ class AdhocQueryAdhocQueryDetailsArgs:
         pulumi.set(self, "query", value)
 
 
+if not MYPY:
+    class AdhocQueryAdhocQueryDetailsAdhocQueryResourceArgsDict(TypedDict):
+        region: NotRequired[pulumi.Input[str]]
+        """
+        Region in which adhoc query needs to be run
+        """
+        resource_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        List of OCIDs on which query needs to be run
+        """
+        resource_type: NotRequired[pulumi.Input[str]]
+        """
+        Type of resource
+        """
+elif False:
+    AdhocQueryAdhocQueryDetailsAdhocQueryResourceArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AdhocQueryAdhocQueryDetailsAdhocQueryResourceArgs:
     def __init__(__self__, *,
@@ -170,6 +273,39 @@ class AdhocQueryAdhocQueryDetailsAdhocQueryResourceArgs:
         pulumi.set(self, "resource_type", value)
 
 
+if not MYPY:
+    class AdhocQueryAdhocQueryRegionalDetailArgsDict(TypedDict):
+        expected_count: NotRequired[pulumi.Input[str]]
+        """
+        Expected number of instances on which query should run
+        """
+        expired_count: NotRequired[pulumi.Input[str]]
+        """
+        Number of instances on which query expired
+        """
+        failed_count: NotRequired[pulumi.Input[str]]
+        """
+        Number of instances on which query failed
+        """
+        region: NotRequired[pulumi.Input[str]]
+        """
+        Region name
+        """
+        regional_error: NotRequired[pulumi.Input[str]]
+        """
+        error message to show if adhoc query fails in a region
+        """
+        regional_status: NotRequired[pulumi.Input[str]]
+        """
+        adhoc query status of the region
+        """
+        succeeded_count: NotRequired[pulumi.Input[str]]
+        """
+        Number of instances on which query succeeded
+        """
+elif False:
+    AdhocQueryAdhocQueryRegionalDetailArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AdhocQueryAdhocQueryRegionalDetailArgs:
     def __init__(__self__, *,
@@ -289,6 +425,63 @@ class AdhocQueryAdhocQueryRegionalDetailArgs:
         pulumi.set(self, "succeeded_count", value)
 
 
+if not MYPY:
+    class CloudGuardDataSourceDataSourceDetailsArgsDict(TypedDict):
+        data_source_feed_provider: pulumi.Input[str]
+        """
+        (Updatable) Type of data source feed provider (LoggingQuery)
+        """
+        additional_entities_count: NotRequired[pulumi.Input[int]]
+        """
+        (Updatable) The additional entities count used for data source query
+        """
+        description: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Description text for the query
+        """
+        interval_in_minutes: NotRequired[pulumi.Input[int]]
+        """
+        (Updatable) Interval in minutes that query is run periodically.
+        """
+        interval_in_seconds: NotRequired[pulumi.Input[int]]
+        """
+        (Updatable) Interval in minutes which query is run periodically.
+        """
+        logging_query_details: NotRequired[pulumi.Input['CloudGuardDataSourceDataSourceDetailsLoggingQueryDetailsArgsDict']]
+        """
+        (Updatable) Details for a logging query for a data source.
+        """
+        logging_query_type: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Type of logging query for data source (Sighting/Insight)
+        """
+        operator: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Operator used in data source
+        """
+        query: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) The continuous query expression that is run periodically.
+        """
+        query_start_time: NotRequired[pulumi.Input['CloudGuardDataSourceDataSourceDetailsQueryStartTimeArgsDict']]
+        """
+        (Updatable) Start policy for continuous query
+        """
+        regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        (Updatable) List of logging query regions
+        """
+        scheduled_query_scope_details: NotRequired[pulumi.Input[Sequence[pulumi.Input['CloudGuardDataSourceDataSourceDetailsScheduledQueryScopeDetailArgsDict']]]]
+        """
+        (Updatable) Target information in which scheduled query will be run
+        """
+        threshold: NotRequired[pulumi.Input[int]]
+        """
+        (Updatable) The integer value that must be exceeded, fall below or equal to (depending on the operator), for the query result to trigger an event
+        """
+elif False:
+    CloudGuardDataSourceDataSourceDetailsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class CloudGuardDataSourceDataSourceDetailsArgs:
     def __init__(__self__, *,
@@ -503,6 +696,19 @@ class CloudGuardDataSourceDataSourceDetailsArgs:
         pulumi.set(self, "threshold", value)
 
 
+if not MYPY:
+    class CloudGuardDataSourceDataSourceDetailsLoggingQueryDetailsArgsDict(TypedDict):
+        logging_query_type: pulumi.Input[str]
+        """
+        (Updatable) Logging query type for data source
+        """
+        key_entities_count: NotRequired[pulumi.Input[int]]
+        """
+        (Updatable) The key entities count used for data source query
+        """
+elif False:
+    CloudGuardDataSourceDataSourceDetailsLoggingQueryDetailsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class CloudGuardDataSourceDataSourceDetailsLoggingQueryDetailsArgs:
     def __init__(__self__, *,
@@ -541,6 +747,19 @@ class CloudGuardDataSourceDataSourceDetailsLoggingQueryDetailsArgs:
         pulumi.set(self, "key_entities_count", value)
 
 
+if not MYPY:
+    class CloudGuardDataSourceDataSourceDetailsQueryStartTimeArgsDict(TypedDict):
+        start_policy_type: pulumi.Input[str]
+        """
+        (Updatable) Start policy delay timing
+        """
+        query_start_time: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Time when the query can start. If not specified it can start immediately
+        """
+elif False:
+    CloudGuardDataSourceDataSourceDetailsQueryStartTimeArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class CloudGuardDataSourceDataSourceDetailsQueryStartTimeArgs:
     def __init__(__self__, *,
@@ -579,6 +798,23 @@ class CloudGuardDataSourceDataSourceDetailsQueryStartTimeArgs:
         pulumi.set(self, "query_start_time", value)
 
 
+if not MYPY:
+    class CloudGuardDataSourceDataSourceDetailsScheduledQueryScopeDetailArgsDict(TypedDict):
+        region: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) region on which scheduled query needs to be run
+        """
+        resource_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        (Updatable) List of OCIDs on scheduled query needs to run
+        """
+        resource_type: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Type of resource
+        """
+elif False:
+    CloudGuardDataSourceDataSourceDetailsScheduledQueryScopeDetailArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class CloudGuardDataSourceDataSourceDetailsScheduledQueryScopeDetailArgs:
     def __init__(__self__, *,
@@ -634,6 +870,19 @@ class CloudGuardDataSourceDataSourceDetailsScheduledQueryScopeDetailArgs:
         pulumi.set(self, "resource_type", value)
 
 
+if not MYPY:
+    class CloudGuardDataSourceDataSourceDetectorMappingInfoArgsDict(TypedDict):
+        detector_recipe_id: NotRequired[pulumi.Input[str]]
+        """
+        ID of the detector recipe attached to the data source
+        """
+        detector_rule_id: NotRequired[pulumi.Input[str]]
+        """
+        ID of the detector rule attached to the data source
+        """
+elif False:
+    CloudGuardDataSourceDataSourceDetectorMappingInfoArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class CloudGuardDataSourceDataSourceDetectorMappingInfoArgs:
     def __init__(__self__, *,
@@ -673,6 +922,23 @@ class CloudGuardDataSourceDataSourceDetectorMappingInfoArgs:
         pulumi.set(self, "detector_rule_id", value)
 
 
+if not MYPY:
+    class CloudGuardDataSourceRegionStatusDetailArgsDict(TypedDict):
+        region: NotRequired[pulumi.Input[str]]
+        """
+        Data source replication region
+        """
+        status: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Enablement status of data source.
+
+
+        ** 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
+        """
+elif False:
+    CloudGuardDataSourceRegionStatusDetailArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class CloudGuardDataSourceRegionStatusDetailArgs:
     def __init__(__self__, *,
@@ -720,6 +986,23 @@ class CloudGuardDataSourceRegionStatusDetailArgs:
         pulumi.set(self, "status", value)
 
 
+if not MYPY:
+    class DataMaskRuleTargetSelectedArgsDict(TypedDict):
+        kind: pulumi.Input[str]
+        """
+        (Updatable) Kind of target selection to be used
+        """
+        values: NotRequired[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
+        """
+elif False:
+    DataMaskRuleTargetSelectedArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class DataMaskRuleTargetSelectedArgs:
     def __init__(__self__, *,
@@ -766,6 +1049,79 @@ class DataMaskRuleTargetSelectedArgs:
         pulumi.set(self, "values", value)
 
 
+if not MYPY:
+    class DetectorRecipeDetectorRuleArgsDict(TypedDict):
+        details: pulumi.Input['DetectorRecipeDetectorRuleDetailsArgsDict']
+        """
+        (Updatable) Parameters to be updated for a detector rule within a detector recipe.
+        """
+        detector_rule_id: pulumi.Input[str]
+        """
+        (Updatable) Detector recipe rule ID
+        """
+        candidate_responder_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleCandidateResponderRuleArgsDict']]]]
+        """
+        List of responder rules that can be used to remediate this detector rule
+        """
+        data_source_id: NotRequired[pulumi.Input[str]]
+        """
+        The ID of the attached data source
+        """
+        description: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Detector recipe description.
+
+        Avoid entering confidential information.
+        """
+        detector: NotRequired[pulumi.Input[str]]
+        """
+        Detector for the rule
+        """
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Detector recipe display name.
+
+        Avoid entering confidential information.
+        """
+        entities_mappings: NotRequired[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleEntitiesMappingArgsDict']]]]
+        """
+        Data source entities mapping for the detector rule
+        """
+        lifecycle_details: NotRequired[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.
+        """
+        managed_list_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        List of managed list types related to this rule
+        """
+        recommendation: NotRequired[pulumi.Input[str]]
+        """
+        Recommendation for DetectorRecipeDetectorRule resource
+        """
+        resource_type: NotRequired[pulumi.Input[str]]
+        """
+        Resource type of the configuration to which the rule is applied
+        """
+        service_type: NotRequired[pulumi.Input[str]]
+        """
+        Service type of the configuration to which the rule is applied
+        """
+        state: NotRequired[pulumi.Input[str]]
+        """
+        The current lifecycle state of the resource
+        """
+        time_created: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the detector recipe was created Format defined by RFC3339.
+        """
+        time_updated: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the detector recipe was last updated Format defined by RFC3339.
+        """
+elif False:
+    DetectorRecipeDetectorRuleArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class DetectorRecipeDetectorRuleArgs:
     def __init__(__self__, *,
@@ -1035,6 +1391,25 @@ class DetectorRecipeDetectorRuleArgs:
         pulumi.set(self, "time_updated", value)
 
 
+if not MYPY:
+    class DetectorRecipeDetectorRuleCandidateResponderRuleArgsDict(TypedDict):
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Detector recipe display name.
+
+        Avoid entering confidential information.
+        """
+        id: NotRequired[pulumi.Input[str]]
+        """
+        OCID for detector recipe
+        """
+        is_preferred: NotRequired[pulumi.Input[bool]]
+        """
+        Is this the preferred state?
+        """
+elif False:
+    DetectorRecipeDetectorRuleCandidateResponderRuleArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class DetectorRecipeDetectorRuleCandidateResponderRuleArgs:
     def __init__(__self__, *,
@@ -1094,6 +1469,51 @@ class DetectorRecipeDetectorRuleCandidateResponderRuleArgs:
         pulumi.set(self, "is_preferred", value)
 
 
+if not MYPY:
+    class DetectorRecipeDetectorRuleDetailsArgsDict(TypedDict):
+        is_enabled: pulumi.Input[bool]
+        """
+        (Updatable) Enablement status of the detector rule
+        """
+        risk_level: pulumi.Input[str]
+        """
+        (Updatable) The risk level of the detector rule
+        """
+        condition: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) The base condition resource.
+        """
+        configurations: NotRequired[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsConfigurationArgsDict']]]]
+        """
+        (Updatable) List of detector rule configurations
+        """
+        data_source_id: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) The unique identifier of the attached data source
+        """
+        description: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Description for the detector rule
+        """
+        entities_mappings: NotRequired[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsEntitiesMappingArgsDict']]]]
+        """
+        (Updatable) Data source entities mapping for a detector rule
+        """
+        is_configuration_allowed: NotRequired[pulumi.Input[bool]]
+        """
+        Can the rule be configured?
+        """
+        labels: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        (Updatable) User-defined labels for a detector rule
+        """
+        recommendation: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Recommendation for the detector rule
+        """
+elif False:
+    DetectorRecipeDetectorRuleDetailsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class DetectorRecipeDetectorRuleDetailsArgs:
     def __init__(__self__, *,
@@ -1259,6 +1679,31 @@ class DetectorRecipeDetectorRuleDetailsArgs:
         pulumi.set(self, "recommendation", value)
 
 
+if not MYPY:
+    class DetectorRecipeDetectorRuleDetailsConfigurationArgsDict(TypedDict):
+        config_key: pulumi.Input[str]
+        """
+        (Updatable) Unique identifier of the configuration
+        """
+        name: pulumi.Input[str]
+        """
+        (Updatable) Configuration name
+        """
+        data_type: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Configuration data type
+        """
+        value: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Configuration value
+        """
+        values: NotRequired[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsConfigurationValueArgsDict']]]]
+        """
+        (Updatable) List of configuration values
+        """
+elif False:
+    DetectorRecipeDetectorRuleDetailsConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class DetectorRecipeDetectorRuleDetailsConfigurationArgs:
     def __init__(__self__, *,
@@ -1344,6 +1789,23 @@ class DetectorRecipeDetectorRuleDetailsConfigurationArgs:
         pulumi.set(self, "values", value)
 
 
+if not MYPY:
+    class DetectorRecipeDetectorRuleDetailsConfigurationValueArgsDict(TypedDict):
+        list_type: pulumi.Input[str]
+        """
+        (Updatable) Configuration list item type (CUSTOM or MANAGED)
+        """
+        managed_list_type: pulumi.Input[str]
+        """
+        (Updatable) Type of content in the managed list
+        """
+        value: pulumi.Input[str]
+        """
+        (Updatable) Configuration value
+        """
+elif False:
+    DetectorRecipeDetectorRuleDetailsConfigurationValueArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class DetectorRecipeDetectorRuleDetailsConfigurationValueArgs:
     def __init__(__self__, *,
@@ -1396,7 +1858,24 @@ class DetectorRecipeDetectorRuleDetailsConfigurationValueArgs:
         pulumi.set(self, "value", value)
 
 
-@pulumi.input_type
+if not MYPY:
+    class DetectorRecipeDetectorRuleDetailsEntitiesMappingArgsDict(TypedDict):
+        query_field: pulumi.Input[str]
+        """
+        (Updatable) The entity value mapped to a data source query
+        """
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Display name of the entity
+        """
+        entity_type: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Type of entity
+        """
+elif False:
+    DetectorRecipeDetectorRuleDetailsEntitiesMappingArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
 class DetectorRecipeDetectorRuleDetailsEntitiesMappingArgs:
     def __init__(__self__, *,
                  query_field: pulumi.Input[str],
@@ -1450,6 +1929,25 @@ class DetectorRecipeDetectorRuleDetailsEntitiesMappingArgs:
         pulumi.set(self, "entity_type", value)
 
 
+if not MYPY:
+    class DetectorRecipeDetectorRuleEntitiesMappingArgsDict(TypedDict):
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Detector recipe display name.
+
+        Avoid entering confidential information.
+        """
+        entity_type: NotRequired[pulumi.Input[str]]
+        """
+        Type of entity
+        """
+        query_field: NotRequired[pulumi.Input[str]]
+        """
+        The entity value mapped to a data source query
+        """
+elif False:
+    DetectorRecipeDetectorRuleEntitiesMappingArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class DetectorRecipeDetectorRuleEntitiesMappingArgs:
     def __init__(__self__, *,
@@ -1509,6 +2007,79 @@ class DetectorRecipeDetectorRuleEntitiesMappingArgs:
         pulumi.set(self, "query_field", value)
 
 
+if not MYPY:
+    class DetectorRecipeEffectiveDetectorRuleArgsDict(TypedDict):
+        candidate_responder_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleCandidateResponderRuleArgsDict']]]]
+        """
+        List of responder rules that can be used to remediate this detector rule
+        """
+        data_source_id: NotRequired[pulumi.Input[str]]
+        """
+        The ID of the attached data source
+        """
+        description: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Detector recipe description.
+
+        Avoid entering confidential information.
+        """
+        details: NotRequired[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailArgsDict']]]]
+        """
+        Detailed information for a detector.
+        """
+        detector: NotRequired[pulumi.Input[str]]
+        """
+        Detector for the rule
+        """
+        detector_rule_id: NotRequired[pulumi.Input[str]]
+        """
+        The unique identifier of the detector rule.
+        """
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Detector recipe display name.
+
+        Avoid entering confidential information.
+        """
+        entities_mappings: NotRequired[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleEntitiesMappingArgsDict']]]]
+        """
+        Data source entities mapping for the detector rule
+        """
+        lifecycle_details: NotRequired[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.
+        """
+        managed_list_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        List of managed list types related to this rule
+        """
+        recommendation: NotRequired[pulumi.Input[str]]
+        """
+        Recommendation for DetectorRecipeDetectorRule resource
+        """
+        resource_type: NotRequired[pulumi.Input[str]]
+        """
+        Resource type of the configuration to which the rule is applied
+        """
+        service_type: NotRequired[pulumi.Input[str]]
+        """
+        Service type of the configuration to which the rule is applied
+        """
+        state: NotRequired[pulumi.Input[str]]
+        """
+        The current lifecycle state of the resource
+        """
+        time_created: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the detector recipe was created Format defined by RFC3339.
+        """
+        time_updated: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the detector recipe was last updated Format defined by RFC3339.
+        """
+elif False:
+    DetectorRecipeEffectiveDetectorRuleArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class DetectorRecipeEffectiveDetectorRuleArgs:
     def __init__(__self__, *,
@@ -1780,6 +2351,25 @@ class DetectorRecipeEffectiveDetectorRuleArgs:
         pulumi.set(self, "time_updated", value)
 
 
+if not MYPY:
+    class DetectorRecipeEffectiveDetectorRuleCandidateResponderRuleArgsDict(TypedDict):
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Detector recipe display name.
+
+        Avoid entering confidential information.
+        """
+        id: NotRequired[pulumi.Input[str]]
+        """
+        OCID for detector recipe
+        """
+        is_preferred: NotRequired[pulumi.Input[bool]]
+        """
+        Is this the preferred state?
+        """
+elif False:
+    DetectorRecipeEffectiveDetectorRuleCandidateResponderRuleArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class DetectorRecipeEffectiveDetectorRuleCandidateResponderRuleArgs:
     def __init__(__self__, *,
@@ -1839,6 +2429,53 @@ class DetectorRecipeEffectiveDetectorRuleCandidateResponderRuleArgs:
         pulumi.set(self, "is_preferred", value)
 
 
+if not MYPY:
+    class DetectorRecipeEffectiveDetectorRuleDetailArgsDict(TypedDict):
+        condition: NotRequired[pulumi.Input[str]]
+        """
+        The base condition resource.
+        """
+        configurations: NotRequired[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailConfigurationArgsDict']]]]
+        """
+        List of detector rule configurations
+        """
+        data_source_id: NotRequired[pulumi.Input[str]]
+        """
+        The ID of the attached data source
+        """
+        description: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Detector recipe description.
+
+        Avoid entering confidential information.
+        """
+        entities_mappings: NotRequired[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailEntitiesMappingArgsDict']]]]
+        """
+        Data source entities mapping for the detector rule
+        """
+        is_configuration_allowed: NotRequired[pulumi.Input[bool]]
+        """
+        Can the rule be configured?
+        """
+        is_enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Enablement status for the rule
+        """
+        labels: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        User-defined labels for a detector rule
+        """
+        recommendation: NotRequired[pulumi.Input[str]]
+        """
+        Recommendation for DetectorRecipeDetectorRule resource
+        """
+        risk_level: NotRequired[pulumi.Input[str]]
+        """
+        The risk level for the rule
+        """
+elif False:
+    DetectorRecipeEffectiveDetectorRuleDetailArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class DetectorRecipeEffectiveDetectorRuleDetailArgs:
     def __init__(__self__, *,
@@ -2010,6 +2647,31 @@ class DetectorRecipeEffectiveDetectorRuleDetailArgs:
         pulumi.set(self, "risk_level", value)
 
 
+if not MYPY:
+    class DetectorRecipeEffectiveDetectorRuleDetailConfigurationArgsDict(TypedDict):
+        config_key: NotRequired[pulumi.Input[str]]
+        """
+        Unique identifier of the configuration
+        """
+        data_type: NotRequired[pulumi.Input[str]]
+        """
+        Configuration data type
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        Configuration name
+        """
+        value: NotRequired[pulumi.Input[str]]
+        """
+        Configuration value
+        """
+        values: NotRequired[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgsDict']]]]
+        """
+        List of configuration values
+        """
+elif False:
+    DetectorRecipeEffectiveDetectorRuleDetailConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class DetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs:
     def __init__(__self__, *,
@@ -2097,6 +2759,23 @@ class DetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs:
         pulumi.set(self, "values", value)
 
 
+if not MYPY:
+    class DetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgsDict(TypedDict):
+        list_type: NotRequired[pulumi.Input[str]]
+        """
+        Configuration list item type (CUSTOM or MANAGED)
+        """
+        managed_list_type: NotRequired[pulumi.Input[str]]
+        """
+        Type of content in the managed list
+        """
+        value: NotRequired[pulumi.Input[str]]
+        """
+        Configuration value
+        """
+elif False:
+    DetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class DetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs:
     def __init__(__self__, *,
@@ -2152,6 +2831,25 @@ class DetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs:
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class DetectorRecipeEffectiveDetectorRuleDetailEntitiesMappingArgsDict(TypedDict):
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Detector recipe display name.
+
+        Avoid entering confidential information.
+        """
+        entity_type: NotRequired[pulumi.Input[str]]
+        """
+        Type of entity
+        """
+        query_field: NotRequired[pulumi.Input[str]]
+        """
+        The entity value mapped to a data source query
+        """
+elif False:
+    DetectorRecipeEffectiveDetectorRuleDetailEntitiesMappingArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class DetectorRecipeEffectiveDetectorRuleDetailEntitiesMappingArgs:
     def __init__(__self__, *,
@@ -2211,6 +2909,25 @@ class DetectorRecipeEffectiveDetectorRuleDetailEntitiesMappingArgs:
         pulumi.set(self, "query_field", value)
 
 
+if not MYPY:
+    class DetectorRecipeEffectiveDetectorRuleEntitiesMappingArgsDict(TypedDict):
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Detector recipe display name.
+
+        Avoid entering confidential information.
+        """
+        entity_type: NotRequired[pulumi.Input[str]]
+        """
+        Type of entity
+        """
+        query_field: NotRequired[pulumi.Input[str]]
+        """
+        The entity value mapped to a data source query
+        """
+elif False:
+    DetectorRecipeEffectiveDetectorRuleEntitiesMappingArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class DetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs:
     def __init__(__self__, *,
@@ -2270,6 +2987,63 @@ class DetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs:
         pulumi.set(self, "query_field", value)
 
 
+if not MYPY:
+    class ResponderRecipeEffectiveResponderRuleArgsDict(TypedDict):
+        compartment_id: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Compartment OCID
+        """
+        description: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Responder recipe description.
+
+        Avoid entering confidential information.
+        """
+        details: NotRequired[pulumi.Input[Sequence[pulumi.Input['ResponderRecipeEffectiveResponderRuleDetailArgsDict']]]]
+        """
+        Detailed information for a responder rule
+        """
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Responder recipe display name.
+
+        Avoid entering confidential information.
+        """
+        lifecycle_details: NotRequired[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.
+        """
+        policies: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        List of policies
+        """
+        responder_rule_id: NotRequired[pulumi.Input[str]]
+        """
+        Unique identifier for the responder rule
+        """
+        state: NotRequired[pulumi.Input[str]]
+        """
+        The current lifecycle state of the example
+        """
+        supported_modes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Supported execution modes for the responder rule
+        """
+        time_created: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the responder recipe was created. Format defined by RFC3339.
+        """
+        time_updated: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the responder recipe was last updated. Format defined by RFC3339.
+        """
+        type: NotRequired[pulumi.Input[str]]
+        """
+        Type of responder
+        """
+elif False:
+    ResponderRecipeEffectiveResponderRuleArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ResponderRecipeEffectiveResponderRuleArgs:
     def __init__(__self__, *,
@@ -2477,6 +3251,27 @@ class ResponderRecipeEffectiveResponderRuleArgs:
         pulumi.set(self, "type", value)
 
 
+if not MYPY:
+    class ResponderRecipeEffectiveResponderRuleDetailArgsDict(TypedDict):
+        condition: NotRequired[pulumi.Input[str]]
+        """
+        The base condition resource.
+        """
+        configurations: NotRequired[pulumi.Input[Sequence[pulumi.Input['ResponderRecipeEffectiveResponderRuleDetailConfigurationArgsDict']]]]
+        """
+        List of responder rule configurations
+        """
+        is_enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Enabled state for the responder rule
+        """
+        mode: NotRequired[pulumi.Input[str]]
+        """
+        Execution mode for the responder rule
+        """
+elif False:
+    ResponderRecipeEffectiveResponderRuleDetailArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ResponderRecipeEffectiveResponderRuleDetailArgs:
     def __init__(__self__, *,
@@ -2548,6 +3343,23 @@ class ResponderRecipeEffectiveResponderRuleDetailArgs:
         pulumi.set(self, "mode", value)
 
 
+if not MYPY:
+    class ResponderRecipeEffectiveResponderRuleDetailConfigurationArgsDict(TypedDict):
+        config_key: NotRequired[pulumi.Input[str]]
+        """
+        Unique identifier of the configuration
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        Configuration name
+        """
+        value: NotRequired[pulumi.Input[str]]
+        """
+        Configuration value
+        """
+elif False:
+    ResponderRecipeEffectiveResponderRuleDetailConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ResponderRecipeEffectiveResponderRuleDetailConfigurationArgs:
     def __init__(__self__, *,
@@ -2603,6 +3415,63 @@ class ResponderRecipeEffectiveResponderRuleDetailConfigurationArgs:
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class ResponderRecipeResponderRuleArgsDict(TypedDict):
+        details: pulumi.Input['ResponderRecipeResponderRuleDetailsArgsDict']
+        """
+        (Updatable) Parameters to be updated for a responder rule within a responder recipe.
+        """
+        responder_rule_id: pulumi.Input[str]
+        """
+        (Updatable) Unique identifier for the responder rule
+        """
+        compartment_id: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Compartment OCID
+        """
+        description: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Responder recipe description.
+
+        Avoid entering confidential information.
+        """
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Responder recipe display name.
+
+        Avoid entering confidential information.
+        """
+        lifecycle_details: NotRequired[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.
+        """
+        policies: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        List of policies
+        """
+        state: NotRequired[pulumi.Input[str]]
+        """
+        The current lifecycle state of the example
+        """
+        supported_modes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Supported execution modes for the responder rule
+        """
+        time_created: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the responder recipe was created. Format defined by RFC3339.
+        """
+        time_updated: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the responder recipe was last updated. Format defined by RFC3339.
+        """
+        type: NotRequired[pulumi.Input[str]]
+        """
+        Type of responder
+        """
+elif False:
+    ResponderRecipeResponderRuleArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ResponderRecipeResponderRuleArgs:
     def __init__(__self__, *,
@@ -2808,6 +3677,27 @@ class ResponderRecipeResponderRuleArgs:
         pulumi.set(self, "type", value)
 
 
+if not MYPY:
+    class ResponderRecipeResponderRuleDetailsArgsDict(TypedDict):
+        is_enabled: pulumi.Input[bool]
+        """
+        (Updatable) Enablement state for the responder rule
+        """
+        condition: NotRequired[pulumi.Input[str]]
+        """
+        The base condition resource.
+        """
+        configurations: NotRequired[pulumi.Input[Sequence[pulumi.Input['ResponderRecipeResponderRuleDetailsConfigurationArgsDict']]]]
+        """
+        List of responder rule configurations
+        """
+        mode: NotRequired[pulumi.Input[str]]
+        """
+        Execution mode for the responder rule
+        """
+elif False:
+    ResponderRecipeResponderRuleDetailsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ResponderRecipeResponderRuleDetailsArgs:
     def __init__(__self__, *,
@@ -2878,6 +3768,23 @@ class ResponderRecipeResponderRuleDetailsArgs:
         pulumi.set(self, "mode", value)
 
 
+if not MYPY:
+    class ResponderRecipeResponderRuleDetailsConfigurationArgsDict(TypedDict):
+        config_key: NotRequired[pulumi.Input[str]]
+        """
+        Unique identifier of the configuration
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        Configuration name
+        """
+        value: NotRequired[pulumi.Input[str]]
+        """
+        Configuration value
+        """
+elif False:
+    ResponderRecipeResponderRuleDetailsConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ResponderRecipeResponderRuleDetailsConfigurationArgs:
     def __init__(__self__, *,
@@ -2933,6 +3840,27 @@ class ResponderRecipeResponderRuleDetailsConfigurationArgs:
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class TargetTargetDetailArgsDict(TypedDict):
+        security_zone_display_name: NotRequired[pulumi.Input[str]]
+        """
+        The name of the security zone to associate with this compartment.
+        """
+        security_zone_id: NotRequired[pulumi.Input[str]]
+        """
+        The OCID of the security zone to associate with this compartment
+        """
+        target_resource_type: NotRequired[pulumi.Input[str]]
+        """
+        Type of resource that target support (COMPARTMENT/FACLOUD)
+        """
+        target_security_zone_recipes: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetailTargetSecurityZoneRecipeArgsDict']]]]
+        """
+        The list of security zone recipes to associate with this compartment
+        """
+elif False:
+    TargetTargetDetailArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TargetTargetDetailArgs:
     def __init__(__self__, *,
@@ -2983,26 +3911,89 @@ class TargetTargetDetailArgs:
     @pulumi.getter(name="targetResourceType")
     def target_resource_type(self) -> Optional[pulumi.Input[str]]:
         """
-        Type of resource that target support (COMPARTMENT/FACLOUD)
+        Type of resource that target support (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 with this compartment
+        """
+        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)
+
+
+if not MYPY:
+    class TargetTargetDetailTargetSecurityZoneRecipeArgsDict(TypedDict):
+        compartment_id: NotRequired[pulumi.Input[str]]
+        """
+        Compartment OCID where the resource is created
+        """
+        defined_tags: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        (Updatable) Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
+        """
+        description: NotRequired[pulumi.Input[str]]
+        """
+        The target description.
+
+        Avoid entering confidential information.
+        """
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Display name for the target.
+
+        Avoid entering confidential information.
+        """
+        freeform_tags: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        (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.
+        """
+        id: NotRequired[pulumi.Input[str]]
+        """
+        Unique identifier of target responder recipe that can't be changed after creation
+        """
+        lifecycle_details: NotRequired[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.
+        """
+        owner: NotRequired[pulumi.Input[str]]
+        """
+        Owner of target responder recipe
+        """
+        security_policies: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The list of security policy IDs that are included in the recipe
+        """
+        state: NotRequired[pulumi.Input[str]]
         """
-        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']]]]:
+        (Updatable) The enablement state of the detector rule
         """
-        The list of security zone recipes to associate with this compartment
+        system_tags: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
         """
-        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)
-
+        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"}`
+        """
+        time_created: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the target was created. Format defined by RFC3339.
+        """
+        time_updated: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the target was last updated. Format defined by RFC3339.
+        """
+elif False:
+    TargetTargetDetailTargetSecurityZoneRecipeArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class TargetTargetDetailTargetSecurityZoneRecipeArgs:
@@ -3231,6 +4222,67 @@ class TargetTargetDetailTargetSecurityZoneRecipeArgs:
         pulumi.set(self, "time_updated", value)
 
 
+if not MYPY:
+    class TargetTargetDetectorRecipeArgsDict(TypedDict):
+        detector_recipe_id: pulumi.Input[str]
+        """
+        Unique identifier for the target detector recipe
+        """
+        compartment_id: NotRequired[pulumi.Input[str]]
+        """
+        Compartment OCID where the resource is created
+        """
+        description: NotRequired[pulumi.Input[str]]
+        """
+        The target description.
+
+        Avoid entering confidential information.
+        """
+        detector: NotRequired[pulumi.Input[str]]
+        """
+        Detector type for the rule
+        """
+        detector_recipe_type: NotRequired[pulumi.Input[str]]
+        """
+        Recipe type ( STANDARD, ENTERPRISE )
+        """
+        detector_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleArgsDict']]]]
+        """
+        (Updatable) List of overrides to be applied to detector rules associated with the target
+        """
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Display name for the target.
+
+        Avoid entering confidential information.
+        """
+        effective_detector_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleArgsDict']]]]
+        """
+        List of currently enabled detector rules for the detector type for recipe after applying defaults
+        """
+        id: NotRequired[pulumi.Input[str]]
+        """
+        Unique identifier of target responder recipe that can't be changed after creation
+        """
+        owner: NotRequired[pulumi.Input[str]]
+        """
+        Owner of target responder recipe
+        """
+        state: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) The enablement state of the detector rule
+        """
+        time_created: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the target was created. Format defined by RFC3339.
+        """
+        time_updated: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the target was last updated. Format defined by RFC3339.
+        """
+elif False:
+    TargetTargetDetectorRecipeArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TargetTargetDetectorRecipeArgs:
     def __init__(__self__, *,
@@ -3453,6 +4505,75 @@ class TargetTargetDetectorRecipeArgs:
         pulumi.set(self, "time_updated", value)
 
 
+if not MYPY:
+    class TargetTargetDetectorRecipeDetectorRuleArgsDict(TypedDict):
+        details: pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsArgsDict']
+        """
+        (Updatable) Parameters to update detector rule configuration details in a detector recipe attached to a target.
+        """
+        detector_rule_id: pulumi.Input[str]
+        """
+        (Updatable) Unique identifier for the detector rule
+        """
+        data_source_id: NotRequired[pulumi.Input[str]]
+        """
+        The ID of the attached data source
+        """
+        description: NotRequired[pulumi.Input[str]]
+        """
+        The target description.
+
+        Avoid entering confidential information.
+        """
+        detector: NotRequired[pulumi.Input[str]]
+        """
+        Detector type for the rule
+        """
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Display name for the target.
+
+        Avoid entering confidential information.
+        """
+        entities_mappings: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleEntitiesMappingArgsDict']]]]
+        """
+        Data source entities mapping for a detector rule
+        """
+        lifecycle_details: NotRequired[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.
+        """
+        managed_list_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        List of managed list types related to this rule
+        """
+        recommendation: NotRequired[pulumi.Input[str]]
+        """
+        Recommendation for TargetDetectorRecipeDetectorRule resource
+        """
+        resource_type: NotRequired[pulumi.Input[str]]
+        """
+        The type of resource which is monitored by the detector rule. For example, Instance, Database, VCN, Policy. To find the resource type for a particular rule, see [Detector Recipe Reference] (/iaas/cloud-guard/using/detect-recipes.htm#detect-recipes-reference).
+        """
+        service_type: NotRequired[pulumi.Input[str]]
+        """
+        Service type of the configuration to which the rule is applied
+        """
+        state: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) The enablement state of the detector rule
+        """
+        time_created: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the target was created. Format defined by RFC3339.
+        """
+        time_updated: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the target was last updated. Format defined by RFC3339.
+        """
+elif False:
+    TargetTargetDetectorRecipeDetectorRuleArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TargetTargetDetectorRecipeDetectorRuleArgs:
     def __init__(__self__, *,
@@ -3706,6 +4827,35 @@ class TargetTargetDetectorRecipeDetectorRuleArgs:
         pulumi.set(self, "time_updated", value)
 
 
+if not MYPY:
+    class TargetTargetDetectorRecipeDetectorRuleDetailsArgsDict(TypedDict):
+        condition_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroupArgsDict']]]]
+        """
+        (Updatable) Condition group corresponding to each compartment
+        """
+        configurations: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationArgsDict']]]]
+        """
+        List of responder rule configurations
+        """
+        is_configuration_allowed: NotRequired[pulumi.Input[bool]]
+        """
+        Configuration allowed or not
+        """
+        is_enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Enabled state for the responder rule
+        """
+        labels: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        User-defined labels for a detector rule
+        """
+        risk_level: NotRequired[pulumi.Input[str]]
+        """
+        The risk level of the detector rule
+        """
+elif False:
+    TargetTargetDetectorRecipeDetectorRuleDetailsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TargetTargetDetectorRecipeDetectorRuleDetailsArgs:
     def __init__(__self__, *,
@@ -3809,6 +4959,19 @@ class TargetTargetDetectorRecipeDetectorRuleDetailsArgs:
         pulumi.set(self, "risk_level", value)
 
 
+if not MYPY:
+    class TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroupArgsDict(TypedDict):
+        compartment_id: pulumi.Input[str]
+        """
+        (Updatable) Compartment OCID associated with condition
+        """
+        condition: pulumi.Input[str]
+        """
+        (Updatable) The base condition resource.
+        """
+elif False:
+    TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroupArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroupArgs:
     def __init__(__self__, *,
@@ -3846,6 +5009,31 @@ class TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroupArgs:
         pulumi.set(self, "condition", value)
 
 
+if not MYPY:
+    class TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationArgsDict(TypedDict):
+        config_key: NotRequired[pulumi.Input[str]]
+        """
+        Unique identifier of the configuration
+        """
+        data_type: NotRequired[pulumi.Input[str]]
+        """
+        Configuration data type
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        Configuration name
+        """
+        value: NotRequired[pulumi.Input[str]]
+        """
+        Configuration value
+        """
+        values: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueArgsDict']]]]
+        """
+        List of configuration values
+        """
+elif False:
+    TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationArgs:
     def __init__(__self__, *,
@@ -3933,6 +5121,23 @@ class TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationArgs:
         pulumi.set(self, "values", value)
 
 
+if not MYPY:
+    class TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueArgsDict(TypedDict):
+        list_type: NotRequired[pulumi.Input[str]]
+        """
+        Configuration list item type (CUSTOM or MANAGED)
+        """
+        managed_list_type: NotRequired[pulumi.Input[str]]
+        """
+        Type of content in the managed list
+        """
+        value: NotRequired[pulumi.Input[str]]
+        """
+        Configuration value
+        """
+elif False:
+    TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueArgs:
     def __init__(__self__, *,
@@ -3988,6 +5193,25 @@ class TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueArgs:
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class TargetTargetDetectorRecipeDetectorRuleEntitiesMappingArgsDict(TypedDict):
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Display name for the target.
+
+        Avoid entering confidential information.
+        """
+        entity_type: NotRequired[pulumi.Input[str]]
+        """
+        Type of entity
+        """
+        query_field: NotRequired[pulumi.Input[str]]
+        """
+        The entity value mapped to a data source query
+        """
+elif False:
+    TargetTargetDetectorRecipeDetectorRuleEntitiesMappingArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TargetTargetDetectorRecipeDetectorRuleEntitiesMappingArgs:
     def __init__(__self__, *,
@@ -4047,6 +5271,75 @@ class TargetTargetDetectorRecipeDetectorRuleEntitiesMappingArgs:
         pulumi.set(self, "query_field", value)
 
 
+if not MYPY:
+    class TargetTargetDetectorRecipeEffectiveDetectorRuleArgsDict(TypedDict):
+        data_source_id: NotRequired[pulumi.Input[str]]
+        """
+        The ID of the attached data source
+        """
+        description: NotRequired[pulumi.Input[str]]
+        """
+        The target description.
+
+        Avoid entering confidential information.
+        """
+        details: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailArgsDict']]]]
+        """
+        Detailed information for a responder rule
+        """
+        detector: NotRequired[pulumi.Input[str]]
+        """
+        Detector type for the rule
+        """
+        detector_rule_id: NotRequired[pulumi.Input[str]]
+        """
+        The unique identifier of the detector rule
+        """
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Display name for the target.
+
+        Avoid entering confidential information.
+        """
+        entities_mappings: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleEntitiesMappingArgsDict']]]]
+        """
+        Data source entities mapping for a detector rule
+        """
+        lifecycle_details: NotRequired[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.
+        """
+        managed_list_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        List of managed list types related to this rule
+        """
+        recommendation: NotRequired[pulumi.Input[str]]
+        """
+        Recommendation for TargetDetectorRecipeDetectorRule resource
+        """
+        resource_type: NotRequired[pulumi.Input[str]]
+        """
+        The type of resource which is monitored by the detector rule. For example, Instance, Database, VCN, Policy. To find the resource type for a particular rule, see [Detector Recipe Reference] (/iaas/cloud-guard/using/detect-recipes.htm#detect-recipes-reference).
+        """
+        service_type: NotRequired[pulumi.Input[str]]
+        """
+        Service type of the configuration to which the rule is applied
+        """
+        state: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) The enablement state of the detector rule
+        """
+        time_created: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the target was created. Format defined by RFC3339.
+        """
+        time_updated: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the target was last updated. Format defined by RFC3339.
+        """
+elif False:
+    TargetTargetDetectorRecipeEffectiveDetectorRuleArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TargetTargetDetectorRecipeEffectiveDetectorRuleArgs:
     def __init__(__self__, *,
@@ -4293,14 +5586,43 @@ class TargetTargetDetectorRecipeEffectiveDetectorRuleArgs:
     @pulumi.getter(name="timeUpdated")
     def time_updated(self) -> Optional[pulumi.Input[str]]:
         """
-        The date and time the target was last updated. Format defined by RFC3339.
+        The date and time the target was last 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)
+
+
+if not MYPY:
+    class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailArgsDict(TypedDict):
+        condition_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConditionGroupArgsDict']]]]
+        """
+        Condition group corresponding to each compartment
+        """
+        configurations: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationArgsDict']]]]
+        """
+        List of responder rule configurations
+        """
+        is_configuration_allowed: NotRequired[pulumi.Input[bool]]
+        """
+        Configuration allowed or not
+        """
+        is_enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Enabled state for the responder rule
+        """
+        labels: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
         """
-        return pulumi.get(self, "time_updated")
-
-    @time_updated.setter
-    def time_updated(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "time_updated", value)
-
+        User-defined labels for a detector rule
+        """
+        risk_level: NotRequired[pulumi.Input[str]]
+        """
+        The risk level of the detector rule
+        """
+elif False:
+    TargetTargetDetectorRecipeEffectiveDetectorRuleDetailArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailArgs:
@@ -4405,6 +5727,19 @@ class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailArgs:
         pulumi.set(self, "risk_level", value)
 
 
+if not MYPY:
+    class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConditionGroupArgsDict(TypedDict):
+        compartment_id: NotRequired[pulumi.Input[str]]
+        """
+        Compartment OCID where the resource is created
+        """
+        condition: NotRequired[pulumi.Input[str]]
+        """
+        The base condition resource.
+        """
+elif False:
+    TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConditionGroupArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConditionGroupArgs:
     def __init__(__self__, *,
@@ -4444,6 +5779,31 @@ class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConditionGroupArgs:
         pulumi.set(self, "condition", value)
 
 
+if not MYPY:
+    class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationArgsDict(TypedDict):
+        config_key: NotRequired[pulumi.Input[str]]
+        """
+        Unique identifier of the configuration
+        """
+        data_type: NotRequired[pulumi.Input[str]]
+        """
+        Configuration data type
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        Configuration name
+        """
+        value: NotRequired[pulumi.Input[str]]
+        """
+        Configuration value
+        """
+        values: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgsDict']]]]
+        """
+        List of configuration values
+        """
+elif False:
+    TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs:
     def __init__(__self__, *,
@@ -4531,6 +5891,23 @@ class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs:
         pulumi.set(self, "values", value)
 
 
+if not MYPY:
+    class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgsDict(TypedDict):
+        list_type: NotRequired[pulumi.Input[str]]
+        """
+        Configuration list item type (CUSTOM or MANAGED)
+        """
+        managed_list_type: NotRequired[pulumi.Input[str]]
+        """
+        Type of content in the managed list
+        """
+        value: NotRequired[pulumi.Input[str]]
+        """
+        Configuration value
+        """
+elif False:
+    TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs:
     def __init__(__self__, *,
@@ -4586,6 +5963,25 @@ class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArg
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class TargetTargetDetectorRecipeEffectiveDetectorRuleEntitiesMappingArgsDict(TypedDict):
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Display name for the target.
+
+        Avoid entering confidential information.
+        """
+        entity_type: NotRequired[pulumi.Input[str]]
+        """
+        Type of entity
+        """
+        query_field: NotRequired[pulumi.Input[str]]
+        """
+        The entity value mapped to a data source query
+        """
+elif False:
+    TargetTargetDetectorRecipeEffectiveDetectorRuleEntitiesMappingArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TargetTargetDetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs:
     def __init__(__self__, *,
@@ -4645,6 +6041,55 @@ class TargetTargetDetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs:
         pulumi.set(self, "query_field", value)
 
 
+if not MYPY:
+    class TargetTargetResponderRecipeArgsDict(TypedDict):
+        responder_recipe_id: pulumi.Input[str]
+        """
+        Unique identifier for responder recipe
+        """
+        compartment_id: NotRequired[pulumi.Input[str]]
+        """
+        Compartment OCID where the resource is created
+        """
+        description: NotRequired[pulumi.Input[str]]
+        """
+        The target description.
+
+        Avoid entering confidential information.
+        """
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Display name for the target.
+
+        Avoid entering confidential information.
+        """
+        effective_responder_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetResponderRecipeEffectiveResponderRuleArgsDict']]]]
+        """
+        List of currently enabled responder rules for the responder type for recipe after applying defaults
+        """
+        id: NotRequired[pulumi.Input[str]]
+        """
+        Unique identifier of target responder recipe that can't be changed after creation
+        """
+        owner: NotRequired[pulumi.Input[str]]
+        """
+        Owner of target responder recipe
+        """
+        responder_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetResponderRecipeResponderRuleArgsDict']]]]
+        """
+        (Updatable) List of overrides to be applied to responder rules associated with the target
+        """
+        time_created: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the target was created. Format defined by RFC3339.
+        """
+        time_updated: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the target was last updated. Format defined by RFC3339.
+        """
+elif False:
+    TargetTargetResponderRecipeArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TargetTargetResponderRecipeArgs:
     def __init__(__self__, *,
@@ -4819,6 +6264,63 @@ class TargetTargetResponderRecipeArgs:
         pulumi.set(self, "time_updated", value)
 
 
+if not MYPY:
+    class TargetTargetResponderRecipeEffectiveResponderRuleArgsDict(TypedDict):
+        compartment_id: NotRequired[pulumi.Input[str]]
+        """
+        Compartment OCID where the resource is created
+        """
+        description: NotRequired[pulumi.Input[str]]
+        """
+        The target description.
+
+        Avoid entering confidential information.
+        """
+        details: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetResponderRecipeEffectiveResponderRuleDetailArgsDict']]]]
+        """
+        Detailed information for a responder rule
+        """
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Display name for the target.
+
+        Avoid entering confidential information.
+        """
+        lifecycle_details: NotRequired[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.
+        """
+        policies: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        List of policies
+        """
+        responder_rule_id: NotRequired[pulumi.Input[str]]
+        """
+        Unique identifier for the responder rule
+        """
+        state: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) The enablement state of the detector rule
+        """
+        supported_modes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Supported execution modes for the responder rule
+        """
+        time_created: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the target was created. Format defined by RFC3339.
+        """
+        time_updated: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the target was last updated. Format defined by RFC3339.
+        """
+        type: NotRequired[pulumi.Input[str]]
+        """
+        Type of responder
+        """
+elif False:
+    TargetTargetResponderRecipeEffectiveResponderRuleArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TargetTargetResponderRecipeEffectiveResponderRuleArgs:
     def __init__(__self__, *,
@@ -5026,6 +6528,27 @@ class TargetTargetResponderRecipeEffectiveResponderRuleArgs:
         pulumi.set(self, "type", value)
 
 
+if not MYPY:
+    class TargetTargetResponderRecipeEffectiveResponderRuleDetailArgsDict(TypedDict):
+        condition: NotRequired[pulumi.Input[str]]
+        """
+        The base condition resource.
+        """
+        configurations: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetResponderRecipeEffectiveResponderRuleDetailConfigurationArgsDict']]]]
+        """
+        List of responder rule configurations
+        """
+        is_enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Enabled state for the responder rule
+        """
+        mode: NotRequired[pulumi.Input[str]]
+        """
+        Execution mode for the responder rule
+        """
+elif False:
+    TargetTargetResponderRecipeEffectiveResponderRuleDetailArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TargetTargetResponderRecipeEffectiveResponderRuleDetailArgs:
     def __init__(__self__, *,
@@ -5097,6 +6620,23 @@ class TargetTargetResponderRecipeEffectiveResponderRuleDetailArgs:
         pulumi.set(self, "mode", value)
 
 
+if not MYPY:
+    class TargetTargetResponderRecipeEffectiveResponderRuleDetailConfigurationArgsDict(TypedDict):
+        config_key: NotRequired[pulumi.Input[str]]
+        """
+        Unique identifier of the configuration
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        Configuration name
+        """
+        value: NotRequired[pulumi.Input[str]]
+        """
+        Configuration value
+        """
+elif False:
+    TargetTargetResponderRecipeEffectiveResponderRuleDetailConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TargetTargetResponderRecipeEffectiveResponderRuleDetailConfigurationArgs:
     def __init__(__self__, *,
@@ -5152,6 +6692,67 @@ class TargetTargetResponderRecipeEffectiveResponderRuleDetailConfigurationArgs:
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class TargetTargetResponderRecipeResponderRuleArgsDict(TypedDict):
+        details: pulumi.Input['TargetTargetResponderRecipeResponderRuleDetailsArgsDict']
+        """
+        (Updatable) Parameters to update details for a responder rule for a target responder recipe. TargetResponderRuleDetails contains all configurations associated with the ResponderRule, whereas UpdateTargetResponderRecipeResponderRuleDetails refers to the details that are to be updated for ResponderRule.
+        """
+        responder_rule_id: pulumi.Input[str]
+        """
+        (Updatable) Unique identifier for target detector recipe
+
+
+        ** 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
+        """
+        compartment_id: NotRequired[pulumi.Input[str]]
+        """
+        Compartment OCID where the resource is created
+        """
+        description: NotRequired[pulumi.Input[str]]
+        """
+        The target description.
+
+        Avoid entering confidential information.
+        """
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Display name for the target.
+
+        Avoid entering confidential information.
+        """
+        lifecycle_details: NotRequired[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.
+        """
+        policies: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        List of policies
+        """
+        state: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) The enablement state of the detector rule
+        """
+        supported_modes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Supported execution modes for the responder rule
+        """
+        time_created: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the target was created. Format defined by RFC3339.
+        """
+        time_updated: NotRequired[pulumi.Input[str]]
+        """
+        The date and time the target was last updated. Format defined by RFC3339.
+        """
+        type: NotRequired[pulumi.Input[str]]
+        """
+        Type of responder
+        """
+elif False:
+    TargetTargetResponderRecipeResponderRuleArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TargetTargetResponderRecipeResponderRuleArgs:
     def __init__(__self__, *,
@@ -5365,6 +6966,27 @@ class TargetTargetResponderRecipeResponderRuleArgs:
         pulumi.set(self, "type", value)
 
 
+if not MYPY:
+    class TargetTargetResponderRecipeResponderRuleDetailsArgsDict(TypedDict):
+        condition: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) The base condition resource.
+        """
+        configurations: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetResponderRecipeResponderRuleDetailsConfigurationArgsDict']]]]
+        """
+        (Updatable) List of responder rule configurations
+        """
+        is_enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Enabled state for the responder rule
+        """
+        mode: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Execution mode for the responder rule
+        """
+elif False:
+    TargetTargetResponderRecipeResponderRuleDetailsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TargetTargetResponderRecipeResponderRuleDetailsArgs:
     def __init__(__self__, *,
@@ -5436,6 +7058,23 @@ class TargetTargetResponderRecipeResponderRuleDetailsArgs:
         pulumi.set(self, "mode", value)
 
 
+if not MYPY:
+    class TargetTargetResponderRecipeResponderRuleDetailsConfigurationArgsDict(TypedDict):
+        config_key: pulumi.Input[str]
+        """
+        (Updatable) Unique identifier of the configuration
+        """
+        name: pulumi.Input[str]
+        """
+        (Updatable) Configuration name
+        """
+        value: pulumi.Input[str]
+        """
+        (Updatable) Configuration value
+        """
+elif False:
+    TargetTargetResponderRecipeResponderRuleDetailsConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TargetTargetResponderRecipeResponderRuleDetailsConfigurationArgs:
     def __init__(__self__, *,
@@ -5488,6 +7127,14 @@ class TargetTargetResponderRecipeResponderRuleDetailsConfigurationArgs:
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class GetAdhocQueriesFilterArgsDict(TypedDict):
+        name: str
+        values: Sequence[str]
+        regex: NotRequired[bool]
+elif False:
+    GetAdhocQueriesFilterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GetAdhocQueriesFilterArgs:
     def __init__(__self__, *,
@@ -5527,6 +7174,17 @@ class GetAdhocQueriesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
+if not MYPY:
+    class GetDataMaskRulesFilterArgsDict(TypedDict):
+        name: str
+        values: Sequence[str]
+        """
+        Types of targets
+        """
+        regex: NotRequired[bool]
+elif False:
+    GetDataMaskRulesFilterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GetDataMaskRulesFilterArgs:
     def __init__(__self__, *,
@@ -5572,6 +7230,14 @@ class GetDataMaskRulesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
+if not MYPY:
+    class GetDataSourceEventsFilterArgsDict(TypedDict):
+        name: str
+        values: Sequence[str]
+        regex: NotRequired[bool]
+elif False:
+    GetDataSourceEventsFilterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GetDataSourceEventsFilterArgs:
     def __init__(__self__, *,
@@ -5611,6 +7277,14 @@ class GetDataSourceEventsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
+if not MYPY:
+    class GetDataSourcesFilterArgsDict(TypedDict):
+        name: str
+        values: Sequence[str]
+        regex: NotRequired[bool]
+elif False:
+    GetDataSourcesFilterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GetDataSourcesFilterArgs:
     def __init__(__self__, *,
@@ -5650,6 +7324,20 @@ class GetDataSourcesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
+if not MYPY:
+    class GetDetectorRecipesFilterArgsDict(TypedDict):
+        name: str
+        """
+        Configuration name
+        """
+        values: Sequence[str]
+        """
+        List of configuration values
+        """
+        regex: NotRequired[bool]
+elif False:
+    GetDetectorRecipesFilterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GetDetectorRecipesFilterArgs:
     def __init__(__self__, *,
@@ -5699,6 +7387,20 @@ class GetDetectorRecipesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
+if not MYPY:
+    class GetGuardTargetsFilterArgsDict(TypedDict):
+        name: str
+        """
+        Configuration name
+        """
+        values: Sequence[str]
+        """
+        List of configuration values
+        """
+        regex: NotRequired[bool]
+elif False:
+    GetGuardTargetsFilterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GetGuardTargetsFilterArgs:
     def __init__(__self__, *,
@@ -5748,6 +7450,14 @@ class GetGuardTargetsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
+if not MYPY:
+    class GetManagedListsFilterArgsDict(TypedDict):
+        name: str
+        values: Sequence[str]
+        regex: NotRequired[bool]
+elif False:
+    GetManagedListsFilterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GetManagedListsFilterArgs:
     def __init__(__self__, *,
@@ -5787,6 +7497,14 @@ class GetManagedListsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
+if not MYPY:
+    class GetProblemEntitiesFilterArgsDict(TypedDict):
+        name: str
+        values: Sequence[str]
+        regex: NotRequired[bool]
+elif False:
+    GetProblemEntitiesFilterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GetProblemEntitiesFilterArgs:
     def __init__(__self__, *,
@@ -5826,6 +7544,17 @@ class GetProblemEntitiesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
+if not MYPY:
+    class GetResponderRecipesFilterArgsDict(TypedDict):
+        name: str
+        """
+        Configuration name
+        """
+        values: Sequence[str]
+        regex: NotRequired[bool]
+elif False:
+    GetResponderRecipesFilterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GetResponderRecipesFilterArgs:
     def __init__(__self__, *,
@@ -5871,6 +7600,14 @@ class GetResponderRecipesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
+if not MYPY:
+    class GetSavedQueriesFilterArgsDict(TypedDict):
+        name: str
+        values: Sequence[str]
+        regex: NotRequired[bool]
+elif False:
+    GetSavedQueriesFilterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GetSavedQueriesFilterArgs:
     def __init__(__self__, *,
@@ -5910,6 +7647,14 @@ class GetSavedQueriesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
+if not MYPY:
+    class GetSecurityPoliciesFilterArgsDict(TypedDict):
+        name: str
+        values: Sequence[str]
+        regex: NotRequired[bool]
+elif False:
+    GetSecurityPoliciesFilterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GetSecurityPoliciesFilterArgs:
     def __init__(__self__, *,
@@ -5949,6 +7694,14 @@ class GetSecurityPoliciesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
+if not MYPY:
+    class GetSecurityRecipesFilterArgsDict(TypedDict):
+        name: str
+        values: Sequence[str]
+        regex: NotRequired[bool]
+elif False:
+    GetSecurityRecipesFilterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GetSecurityRecipesFilterArgs:
     def __init__(__self__, *,
@@ -5988,6 +7741,14 @@ class GetSecurityRecipesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
+if not MYPY:
+    class GetSecurityZonesFilterArgsDict(TypedDict):
+        name: str
+        values: Sequence[str]
+        regex: NotRequired[bool]
+elif False:
+    GetSecurityZonesFilterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GetSecurityZonesFilterArgs:
     def __init__(__self__, *,
@@ -6027,6 +7788,14 @@ class GetSecurityZonesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
+if not MYPY:
+    class GetWlpAgentsFilterArgsDict(TypedDict):
+        name: str
+        values: Sequence[str]
+        regex: NotRequired[bool]
+elif False:
+    GetWlpAgentsFilterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GetWlpAgentsFilterArgs:
     def __init__(__self__, *,