pulumi-oci 2.26.0a1741415311__py3-none-any.whl → 2.26.0a1741943394__py3-none-any.whl

pulumi_oci/datasafe/get_masking_report.py

@@ -26,7 +26,7 @@ class GetMaskingReportResult:
     """
     A collection of values returned by getMaskingReport.
     """
-    def __init__(__self__, compartment_id=None, id=None, is_drop_temp_tables_enabled=None, is_redo_logging_enabled=None, is_refresh_stats_enabled=None, masking_policy_id=None, masking_report_id=None, masking_work_request_id=None, parallel_degree=None, recompile=None, state=None, target_id=None, time_created=None, time_masking_finished=None, time_masking_started=None, total_masked_columns=None, total_masked_objects=None, total_masked_schemas=None, total_masked_sensitive_types=None, total_masked_values=None):
+    def __init__(__self__, compartment_id=None, id=None, is_drop_temp_tables_enabled=None, is_redo_logging_enabled=None, is_refresh_stats_enabled=None, masking_policy_id=None, masking_report_id=None, masking_status=None, masking_work_request_id=None, parallel_degree=None, recompile=None, state=None, target_id=None, time_created=None, time_masking_finished=None, time_masking_started=None, total_masked_columns=None, total_masked_objects=None, total_masked_schemas=None, total_masked_sensitive_types=None, total_masked_values=None, total_post_masking_script_errors=None, total_pre_masking_script_errors=None):
         if compartment_id and not isinstance(compartment_id, str):
             raise TypeError("Expected argument 'compartment_id' to be a str")
         pulumi.set(__self__, "compartment_id", compartment_id)
@@ -48,6 +48,9 @@ class GetMaskingReportResult:
         if masking_report_id and not isinstance(masking_report_id, str):
             raise TypeError("Expected argument 'masking_report_id' to be a str")
         pulumi.set(__self__, "masking_report_id", masking_report_id)
+        if masking_status and not isinstance(masking_status, str):
+            raise TypeError("Expected argument 'masking_status' to be a str")
+        pulumi.set(__self__, "masking_status", masking_status)
         if masking_work_request_id and not isinstance(masking_work_request_id, str):
             raise TypeError("Expected argument 'masking_work_request_id' to be a str")
         pulumi.set(__self__, "masking_work_request_id", masking_work_request_id)
@@ -87,6 +90,12 @@ class GetMaskingReportResult:
         if total_masked_values and not isinstance(total_masked_values, str):
             raise TypeError("Expected argument 'total_masked_values' to be a str")
         pulumi.set(__self__, "total_masked_values", total_masked_values)
+        if total_post_masking_script_errors and not isinstance(total_post_masking_script_errors, str):
+            raise TypeError("Expected argument 'total_post_masking_script_errors' to be a str")
+        pulumi.set(__self__, "total_post_masking_script_errors", total_post_masking_script_errors)
+        if total_pre_masking_script_errors and not isinstance(total_pre_masking_script_errors, str):
+            raise TypeError("Expected argument 'total_pre_masking_script_errors' to be a str")
+        pulumi.set(__self__, "total_pre_masking_script_errors", total_pre_masking_script_errors)
 
     @property
     @pulumi.getter(name="compartmentId")
@@ -141,6 +150,14 @@ class GetMaskingReportResult:
     def masking_report_id(self) -> str:
         return pulumi.get(self, "masking_report_id")
 
+    @property
+    @pulumi.getter(name="maskingStatus")
+    def masking_status(self) -> str:
+        """
+        The status of the masking job.
+        """
+        return pulumi.get(self, "masking_status")
+
     @property
     @pulumi.getter(name="maskingWorkRequestId")
     def masking_work_request_id(self) -> str:
@@ -245,6 +262,22 @@ class GetMaskingReportResult:
         """
         return pulumi.get(self, "total_masked_values")
 
+    @property
+    @pulumi.getter(name="totalPostMaskingScriptErrors")
+    def total_post_masking_script_errors(self) -> str:
+        """
+        The total number of errors in post-masking script.
+        """
+        return pulumi.get(self, "total_post_masking_script_errors")
+
+    @property
+    @pulumi.getter(name="totalPreMaskingScriptErrors")
+    def total_pre_masking_script_errors(self) -> str:
+        """
+        The total number of errors in pre-masking script.
+        """
+        return pulumi.get(self, "total_pre_masking_script_errors")
+
 
 class AwaitableGetMaskingReportResult(GetMaskingReportResult):
     # pylint: disable=using-constant-test
@@ -259,6 +292,7 @@ class AwaitableGetMaskingReportResult(GetMaskingReportResult):
             is_refresh_stats_enabled=self.is_refresh_stats_enabled,
             masking_policy_id=self.masking_policy_id,
             masking_report_id=self.masking_report_id,
+            masking_status=self.masking_status,
             masking_work_request_id=self.masking_work_request_id,
             parallel_degree=self.parallel_degree,
             recompile=self.recompile,
@@ -271,7 +305,9 @@ class AwaitableGetMaskingReportResult(GetMaskingReportResult):
             total_masked_objects=self.total_masked_objects,
             total_masked_schemas=self.total_masked_schemas,
             total_masked_sensitive_types=self.total_masked_sensitive_types,
-            total_masked_values=self.total_masked_values)
+            total_masked_values=self.total_masked_values,
+            total_post_masking_script_errors=self.total_post_masking_script_errors,
+            total_pre_masking_script_errors=self.total_pre_masking_script_errors)
 
 
 def get_masking_report(masking_report_id: Optional[str] = None,
@@ -306,6 +342,7 @@ def get_masking_report(masking_report_id: Optional[str] = None,
         is_refresh_stats_enabled=pulumi.get(__ret__, 'is_refresh_stats_enabled'),
         masking_policy_id=pulumi.get(__ret__, 'masking_policy_id'),
         masking_report_id=pulumi.get(__ret__, 'masking_report_id'),
+        masking_status=pulumi.get(__ret__, 'masking_status'),
         masking_work_request_id=pulumi.get(__ret__, 'masking_work_request_id'),
         parallel_degree=pulumi.get(__ret__, 'parallel_degree'),
         recompile=pulumi.get(__ret__, 'recompile'),
@@ -318,7 +355,9 @@ def get_masking_report(masking_report_id: Optional[str] = None,
         total_masked_objects=pulumi.get(__ret__, 'total_masked_objects'),
         total_masked_schemas=pulumi.get(__ret__, 'total_masked_schemas'),
         total_masked_sensitive_types=pulumi.get(__ret__, 'total_masked_sensitive_types'),
-        total_masked_values=pulumi.get(__ret__, 'total_masked_values'))
+        total_masked_values=pulumi.get(__ret__, 'total_masked_values'),
+        total_post_masking_script_errors=pulumi.get(__ret__, 'total_post_masking_script_errors'),
+        total_pre_masking_script_errors=pulumi.get(__ret__, 'total_pre_masking_script_errors'))
 def get_masking_report_output(masking_report_id: Optional[pulumi.Input[str]] = None,
                               opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetMaskingReportResult]:
     """
@@ -350,6 +389,7 @@ def get_masking_report_output(masking_report_id: Optional[pulumi.Input[str]] = N
         is_refresh_stats_enabled=pulumi.get(__response__, 'is_refresh_stats_enabled'),
         masking_policy_id=pulumi.get(__response__, 'masking_policy_id'),
         masking_report_id=pulumi.get(__response__, 'masking_report_id'),
+        masking_status=pulumi.get(__response__, 'masking_status'),
         masking_work_request_id=pulumi.get(__response__, 'masking_work_request_id'),
         parallel_degree=pulumi.get(__response__, 'parallel_degree'),
         recompile=pulumi.get(__response__, 'recompile'),
@@ -362,4 +402,6 @@ def get_masking_report_output(masking_report_id: Optional[pulumi.Input[str]] = N
         total_masked_objects=pulumi.get(__response__, 'total_masked_objects'),
         total_masked_schemas=pulumi.get(__response__, 'total_masked_schemas'),
         total_masked_sensitive_types=pulumi.get(__response__, 'total_masked_sensitive_types'),
-        total_masked_values=pulumi.get(__response__, 'total_masked_values')))
+        total_masked_values=pulumi.get(__response__, 'total_masked_values'),
+        total_post_masking_script_errors=pulumi.get(__response__, 'total_post_masking_script_errors'),
+        total_pre_masking_script_errors=pulumi.get(__response__, 'total_pre_masking_script_errors')))

pulumi_oci/datasafe/get_masking_report_masking_errors.py

@@ -0,0 +1,166 @@
+# 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 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
+from . import outputs
+from ._inputs import *
+
+__all__ = [
+    'GetMaskingReportMaskingErrorsResult',
+    'AwaitableGetMaskingReportMaskingErrorsResult',
+    'get_masking_report_masking_errors',
+    'get_masking_report_masking_errors_output',
+]
+
+@pulumi.output_type
+class GetMaskingReportMaskingErrorsResult:
+    """
+    A collection of values returned by getMaskingReportMaskingErrors.
+    """
+    def __init__(__self__, filters=None, id=None, masking_error_collections=None, masking_report_id=None, step_name=None):
+        if filters and not isinstance(filters, list):
+            raise TypeError("Expected argument 'filters' to be a list")
+        pulumi.set(__self__, "filters", filters)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if masking_error_collections and not isinstance(masking_error_collections, list):
+            raise TypeError("Expected argument 'masking_error_collections' to be a list")
+        pulumi.set(__self__, "masking_error_collections", masking_error_collections)
+        if masking_report_id and not isinstance(masking_report_id, str):
+            raise TypeError("Expected argument 'masking_report_id' to be a str")
+        pulumi.set(__self__, "masking_report_id", masking_report_id)
+        if step_name and not isinstance(step_name, str):
+            raise TypeError("Expected argument 'step_name' to be a str")
+        pulumi.set(__self__, "step_name", step_name)
+
+    @property
+    @pulumi.getter
+    def filters(self) -> Optional[Sequence['outputs.GetMaskingReportMaskingErrorsFilterResult']]:
+        return pulumi.get(self, "filters")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The provider-assigned unique ID for this managed resource.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="maskingErrorCollections")
+    def masking_error_collections(self) -> Sequence['outputs.GetMaskingReportMaskingErrorsMaskingErrorCollectionResult']:
+        """
+        The list of masking_error_collection.
+        """
+        return pulumi.get(self, "masking_error_collections")
+
+    @property
+    @pulumi.getter(name="maskingReportId")
+    def masking_report_id(self) -> str:
+        return pulumi.get(self, "masking_report_id")
+
+    @property
+    @pulumi.getter(name="stepName")
+    def step_name(self) -> Optional[str]:
+        """
+        The stepName of the masking error.
+        """
+        return pulumi.get(self, "step_name")
+
+
+class AwaitableGetMaskingReportMaskingErrorsResult(GetMaskingReportMaskingErrorsResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetMaskingReportMaskingErrorsResult(
+            filters=self.filters,
+            id=self.id,
+            masking_error_collections=self.masking_error_collections,
+            masking_report_id=self.masking_report_id,
+            step_name=self.step_name)
+
+
+def get_masking_report_masking_errors(filters: Optional[Sequence[Union['GetMaskingReportMaskingErrorsFilterArgs', 'GetMaskingReportMaskingErrorsFilterArgsDict']]] = None,
+                                      masking_report_id: Optional[str] = None,
+                                      step_name: Optional[str] = None,
+                                      opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetMaskingReportMaskingErrorsResult:
+    """
+    This data source provides the list of Masking Report Masking Errors in Oracle Cloud Infrastructure Data Safe service.
+
+    Gets a list of masking errors in a masking run based on the specified query parameters.
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_oci as oci
+
+    test_masking_report_masking_errors = oci.DataSafe.get_masking_report_masking_errors(masking_report_id=test_masking_report["id"],
+        step_name=masking_report_masking_error_step_name)
+    ```
+
+
+    :param str masking_report_id: The OCID of the masking report.
+    :param str step_name: A filter to return only masking errors that match the specified step name.
+    """
+    __args__ = dict()
+    __args__['filters'] = filters
+    __args__['maskingReportId'] = masking_report_id
+    __args__['stepName'] = step_name
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('oci:DataSafe/getMaskingReportMaskingErrors:getMaskingReportMaskingErrors', __args__, opts=opts, typ=GetMaskingReportMaskingErrorsResult).value
+
+    return AwaitableGetMaskingReportMaskingErrorsResult(
+        filters=pulumi.get(__ret__, 'filters'),
+        id=pulumi.get(__ret__, 'id'),
+        masking_error_collections=pulumi.get(__ret__, 'masking_error_collections'),
+        masking_report_id=pulumi.get(__ret__, 'masking_report_id'),
+        step_name=pulumi.get(__ret__, 'step_name'))
+def get_masking_report_masking_errors_output(filters: Optional[pulumi.Input[Optional[Sequence[Union['GetMaskingReportMaskingErrorsFilterArgs', 'GetMaskingReportMaskingErrorsFilterArgsDict']]]]] = None,
+                                             masking_report_id: Optional[pulumi.Input[str]] = None,
+                                             step_name: Optional[pulumi.Input[Optional[str]]] = None,
+                                             opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetMaskingReportMaskingErrorsResult]:
+    """
+    This data source provides the list of Masking Report Masking Errors in Oracle Cloud Infrastructure Data Safe service.
+
+    Gets a list of masking errors in a masking run based on the specified query parameters.
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_oci as oci
+
+    test_masking_report_masking_errors = oci.DataSafe.get_masking_report_masking_errors(masking_report_id=test_masking_report["id"],
+        step_name=masking_report_masking_error_step_name)
+    ```
+
+
+    :param str masking_report_id: The OCID of the masking report.
+    :param str step_name: A filter to return only masking errors that match the specified step name.
+    """
+    __args__ = dict()
+    __args__['filters'] = filters
+    __args__['maskingReportId'] = masking_report_id
+    __args__['stepName'] = step_name
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('oci:DataSafe/getMaskingReportMaskingErrors:getMaskingReportMaskingErrors', __args__, opts=opts, typ=GetMaskingReportMaskingErrorsResult)
+    return __ret__.apply(lambda __response__: GetMaskingReportMaskingErrorsResult(
+        filters=pulumi.get(__response__, 'filters'),
+        id=pulumi.get(__response__, 'id'),
+        masking_error_collections=pulumi.get(__response__, 'masking_error_collections'),
+        masking_report_id=pulumi.get(__response__, 'masking_report_id'),
+        step_name=pulumi.get(__response__, 'step_name')))

pulumi_oci/datasafe/get_security_assessment_finding.py

@@ -28,13 +28,16 @@ class GetSecurityAssessmentFindingResult:
     """
     A collection of values returned by getSecurityAssessmentFinding.
     """
-    def __init__(__self__, access_level=None, compartment_id_in_subtree=None, filters=None, finding_key=None, findings=None, id=None, is_top_finding=None, references=None, security_assessment_id=None, severity=None, state=None, target_id=None):
+    def __init__(__self__, access_level=None, compartment_id_in_subtree=None, fields=None, filters=None, finding_key=None, findings=None, id=None, is_top_finding=None, references=None, scim_query=None, security_assessment_id=None, severity=None, state=None, target_id=None):
         if access_level and not isinstance(access_level, str):
             raise TypeError("Expected argument 'access_level' to be a str")
         pulumi.set(__self__, "access_level", access_level)
         if compartment_id_in_subtree and not isinstance(compartment_id_in_subtree, bool):
             raise TypeError("Expected argument 'compartment_id_in_subtree' to be a bool")
         pulumi.set(__self__, "compartment_id_in_subtree", compartment_id_in_subtree)
+        if fields and not isinstance(fields, list):
+            raise TypeError("Expected argument 'fields' to be a list")
+        pulumi.set(__self__, "fields", fields)
         if filters and not isinstance(filters, list):
             raise TypeError("Expected argument 'filters' to be a list")
         pulumi.set(__self__, "filters", filters)
@@ -53,6 +56,9 @@ class GetSecurityAssessmentFindingResult:
         if references and not isinstance(references, str):
             raise TypeError("Expected argument 'references' to be a str")
         pulumi.set(__self__, "references", references)
+        if scim_query and not isinstance(scim_query, str):
+            raise TypeError("Expected argument 'scim_query' to be a str")
+        pulumi.set(__self__, "scim_query", scim_query)
         if security_assessment_id and not isinstance(security_assessment_id, str):
             raise TypeError("Expected argument 'security_assessment_id' to be a str")
         pulumi.set(__self__, "security_assessment_id", security_assessment_id)
@@ -76,6 +82,11 @@ class GetSecurityAssessmentFindingResult:
     def compartment_id_in_subtree(self) -> Optional[bool]:
         return pulumi.get(self, "compartment_id_in_subtree")
 
+    @property
+    @pulumi.getter
+    def fields(self) -> Optional[Sequence[str]]:
+        return pulumi.get(self, "fields")
+
     @property
     @pulumi.getter
     def filters(self) -> Optional[Sequence['outputs.GetSecurityAssessmentFindingFilterResult']]:
@@ -109,6 +120,11 @@ class GetSecurityAssessmentFindingResult:
     def references(self) -> Optional[str]:
         return pulumi.get(self, "references")
 
+    @property
+    @pulumi.getter(name="scimQuery")
+    def scim_query(self) -> Optional[str]:
+        return pulumi.get(self, "scim_query")
+
     @property
     @pulumi.getter(name="securityAssessmentId")
     def security_assessment_id(self) -> str:
@@ -138,12 +154,14 @@ class AwaitableGetSecurityAssessmentFindingResult(GetSecurityAssessmentFindingRe
         return GetSecurityAssessmentFindingResult(
             access_level=self.access_level,
             compartment_id_in_subtree=self.compartment_id_in_subtree,
+            fields=self.fields,
             filters=self.filters,
             finding_key=self.finding_key,
             findings=self.findings,
             id=self.id,
             is_top_finding=self.is_top_finding,
             references=self.references,
+            scim_query=self.scim_query,
             security_assessment_id=self.security_assessment_id,
             severity=self.severity,
             state=self.state,
@@ -152,10 +170,12 @@ class AwaitableGetSecurityAssessmentFindingResult(GetSecurityAssessmentFindingRe
 
 def get_security_assessment_finding(access_level: Optional[str] = None,
                                     compartment_id_in_subtree: Optional[bool] = None,
+                                    fields: Optional[Sequence[str]] = None,
                                     filters: Optional[Sequence[Union['GetSecurityAssessmentFindingFilterArgs', 'GetSecurityAssessmentFindingFilterArgsDict']]] = None,
                                     finding_key: Optional[str] = None,
                                     is_top_finding: Optional[bool] = None,
                                     references: Optional[str] = None,
+                                    scim_query: Optional[str] = None,
                                     security_assessment_id: Optional[str] = None,
                                     severity: Optional[str] = None,
                                     state: Optional[str] = None,
@@ -167,10 +187,12 @@ def get_security_assessment_finding(access_level: Optional[str] = None,
     __args__ = dict()
     __args__['accessLevel'] = access_level
     __args__['compartmentIdInSubtree'] = compartment_id_in_subtree
+    __args__['fields'] = fields
     __args__['filters'] = filters
     __args__['findingKey'] = finding_key
     __args__['isTopFinding'] = is_top_finding
     __args__['references'] = references
+    __args__['scimQuery'] = scim_query
     __args__['securityAssessmentId'] = security_assessment_id
     __args__['severity'] = severity
     __args__['state'] = state
@@ -181,22 +203,26 @@ def get_security_assessment_finding(access_level: Optional[str] = None,
     return AwaitableGetSecurityAssessmentFindingResult(
         access_level=pulumi.get(__ret__, 'access_level'),
         compartment_id_in_subtree=pulumi.get(__ret__, 'compartment_id_in_subtree'),
+        fields=pulumi.get(__ret__, 'fields'),
         filters=pulumi.get(__ret__, 'filters'),
         finding_key=pulumi.get(__ret__, 'finding_key'),
         findings=pulumi.get(__ret__, 'findings'),
         id=pulumi.get(__ret__, 'id'),
         is_top_finding=pulumi.get(__ret__, 'is_top_finding'),
         references=pulumi.get(__ret__, 'references'),
+        scim_query=pulumi.get(__ret__, 'scim_query'),
         security_assessment_id=pulumi.get(__ret__, 'security_assessment_id'),
         severity=pulumi.get(__ret__, 'severity'),
         state=pulumi.get(__ret__, 'state'),
         target_id=pulumi.get(__ret__, 'target_id'))
 def get_security_assessment_finding_output(access_level: Optional[pulumi.Input[Optional[str]]] = None,
                                            compartment_id_in_subtree: Optional[pulumi.Input[Optional[bool]]] = None,
+                                           fields: Optional[pulumi.Input[Optional[Sequence[str]]]] = None,
                                            filters: Optional[pulumi.Input[Optional[Sequence[Union['GetSecurityAssessmentFindingFilterArgs', 'GetSecurityAssessmentFindingFilterArgsDict']]]]] = None,
                                            finding_key: Optional[pulumi.Input[Optional[str]]] = None,
                                            is_top_finding: Optional[pulumi.Input[Optional[bool]]] = None,
                                            references: Optional[pulumi.Input[Optional[str]]] = None,
+                                           scim_query: Optional[pulumi.Input[Optional[str]]] = None,
                                            security_assessment_id: Optional[pulumi.Input[str]] = None,
                                            severity: Optional[pulumi.Input[Optional[str]]] = None,
                                            state: Optional[pulumi.Input[Optional[str]]] = None,
@@ -208,10 +234,12 @@ def get_security_assessment_finding_output(access_level: Optional[pulumi.Input[O
     __args__ = dict()
     __args__['accessLevel'] = access_level
     __args__['compartmentIdInSubtree'] = compartment_id_in_subtree
+    __args__['fields'] = fields
     __args__['filters'] = filters
     __args__['findingKey'] = finding_key
     __args__['isTopFinding'] = is_top_finding
     __args__['references'] = references
+    __args__['scimQuery'] = scim_query
     __args__['securityAssessmentId'] = security_assessment_id
     __args__['severity'] = severity
     __args__['state'] = state
@@ -221,12 +249,14 @@ def get_security_assessment_finding_output(access_level: Optional[pulumi.Input[O
     return __ret__.apply(lambda __response__: GetSecurityAssessmentFindingResult(
         access_level=pulumi.get(__response__, 'access_level'),
         compartment_id_in_subtree=pulumi.get(__response__, 'compartment_id_in_subtree'),
+        fields=pulumi.get(__response__, 'fields'),
         filters=pulumi.get(__response__, 'filters'),
         finding_key=pulumi.get(__response__, 'finding_key'),
         findings=pulumi.get(__response__, 'findings'),
         id=pulumi.get(__response__, 'id'),
         is_top_finding=pulumi.get(__response__, 'is_top_finding'),
         references=pulumi.get(__response__, 'references'),
+        scim_query=pulumi.get(__response__, 'scim_query'),
         security_assessment_id=pulumi.get(__response__, 'security_assessment_id'),
         severity=pulumi.get(__response__, 'severity'),
         state=pulumi.get(__response__, 'state'),

pulumi_oci/datasafe/get_security_assessment_findings.py

@@ -28,13 +28,16 @@ class GetSecurityAssessmentFindingsResult:
     """
     A collection of values returned by getSecurityAssessmentFindings.
     """
-    def __init__(__self__, access_level=None, compartment_id_in_subtree=None, filters=None, finding_key=None, findings=None, id=None, is_top_finding=None, references=None, security_assessment_id=None, severity=None, state=None, target_id=None):
+    def __init__(__self__, access_level=None, compartment_id_in_subtree=None, fields=None, filters=None, finding_key=None, findings=None, id=None, is_top_finding=None, references=None, scim_query=None, security_assessment_id=None, severity=None, state=None, target_id=None):
         if access_level and not isinstance(access_level, str):
             raise TypeError("Expected argument 'access_level' to be a str")
         pulumi.set(__self__, "access_level", access_level)
         if compartment_id_in_subtree and not isinstance(compartment_id_in_subtree, bool):
             raise TypeError("Expected argument 'compartment_id_in_subtree' to be a bool")
         pulumi.set(__self__, "compartment_id_in_subtree", compartment_id_in_subtree)
+        if fields and not isinstance(fields, list):
+            raise TypeError("Expected argument 'fields' to be a list")
+        pulumi.set(__self__, "fields", fields)
         if filters and not isinstance(filters, list):
             raise TypeError("Expected argument 'filters' to be a list")
         pulumi.set(__self__, "filters", filters)
@@ -53,6 +56,9 @@ class GetSecurityAssessmentFindingsResult:
         if references and not isinstance(references, str):
             raise TypeError("Expected argument 'references' to be a str")
         pulumi.set(__self__, "references", references)
+        if scim_query and not isinstance(scim_query, str):
+            raise TypeError("Expected argument 'scim_query' to be a str")
+        pulumi.set(__self__, "scim_query", scim_query)
         if security_assessment_id and not isinstance(security_assessment_id, str):
             raise TypeError("Expected argument 'security_assessment_id' to be a str")
         pulumi.set(__self__, "security_assessment_id", security_assessment_id)
@@ -76,6 +82,11 @@ class GetSecurityAssessmentFindingsResult:
     def compartment_id_in_subtree(self) -> Optional[bool]:
         return pulumi.get(self, "compartment_id_in_subtree")
 
+    @property
+    @pulumi.getter
+    def fields(self) -> Optional[Sequence[str]]:
+        return pulumi.get(self, "fields")
+
     @property
     @pulumi.getter
     def filters(self) -> Optional[Sequence['outputs.GetSecurityAssessmentFindingsFilterResult']]:
@@ -118,6 +129,11 @@ class GetSecurityAssessmentFindingsResult:
         """
         return pulumi.get(self, "references")
 
+    @property
+    @pulumi.getter(name="scimQuery")
+    def scim_query(self) -> Optional[str]:
+        return pulumi.get(self, "scim_query")
+
     @property
     @pulumi.getter(name="securityAssessmentId")
     def security_assessment_id(self) -> str:
@@ -156,12 +172,14 @@ class AwaitableGetSecurityAssessmentFindingsResult(GetSecurityAssessmentFindings
         return GetSecurityAssessmentFindingsResult(
             access_level=self.access_level,
             compartment_id_in_subtree=self.compartment_id_in_subtree,
+            fields=self.fields,
             filters=self.filters,
             finding_key=self.finding_key,
             findings=self.findings,
             id=self.id,
             is_top_finding=self.is_top_finding,
             references=self.references,
+            scim_query=self.scim_query,
             security_assessment_id=self.security_assessment_id,
             severity=self.severity,
             state=self.state,
@@ -170,10 +188,12 @@ class AwaitableGetSecurityAssessmentFindingsResult(GetSecurityAssessmentFindings
 
 def get_security_assessment_findings(access_level: Optional[str] = None,
                                      compartment_id_in_subtree: Optional[bool] = None,
+                                     fields: Optional[Sequence[str]] = None,
                                      filters: Optional[Sequence[Union['GetSecurityAssessmentFindingsFilterArgs', 'GetSecurityAssessmentFindingsFilterArgsDict']]] = None,
                                      finding_key: Optional[str] = None,
                                      is_top_finding: Optional[bool] = None,
                                      references: Optional[str] = None,
+                                     scim_query: Optional[str] = None,
                                      security_assessment_id: Optional[str] = None,
                                      severity: Optional[str] = None,
                                      state: Optional[str] = None,
@@ -187,9 +207,14 @@ def get_security_assessment_findings(access_level: Optional[str] = None,
 
     :param str access_level: Valid values are RESTRICTED and ACCESSIBLE. Default is RESTRICTED. Setting this to ACCESSIBLE returns only those compartments for which the user has INSPECT permissions directly or indirectly (permissions can be on a resource in a subcompartment). When set to RESTRICTED permissions are checked and no partial results are displayed.
     :param bool compartment_id_in_subtree: Default is false. When set to true, the hierarchy of compartments is traversed and all compartments and subcompartments in the tenancy are returned. Depends on the 'accessLevel' setting.
+    :param Sequence[str] fields: Specifies a subset of fields to be returned in the response.
     :param str finding_key: Each finding in security assessment has an associated key (think of key as a finding's name). For a given finding, the key will be the same across targets. The user can use these keys to filter the findings.
     :param bool is_top_finding: A filter to return only the findings that are marked as top findings.
-    :param str references: An optional filter to return only findings containing the specified reference.
+    :param str references: An optional filter to return only findings that match the specified reference.
+    :param str scim_query: The scimQuery query parameter accepts filter expressions that use the syntax described in Section 3.2.2.2 of the System for Cross-Domain Identity Management (SCIM) specification, which is available at [RFC3339](https://tools.ietf.org/html/draft-ietf-scim-api-12). In SCIM filtering expressions, text, date, and time values must be enclosed in quotation marks, with date and time values using ISO-8601 format. (Numeric and boolean values should not be quoted.)
+           
+           **Example:** | scimQuery=(severity eq 'high') and (targetId eq 'target_1') scimQuery=(category eq "Users") and (targetId eq "target_1") scimQuery=(reference eq 'CIS') and (targetId eq 'target_1')
+           Supported fields: severity findingKey reference targetId isTopFinding title category remarks details summary isRiskModified
     :param str security_assessment_id: The OCID of the security assessment.
     :param str severity: A filter to return only findings of a particular risk level.
     :param str state: A filter to return only the findings that match the specified lifecycle states.
@@ -198,10 +223,12 @@ def get_security_assessment_findings(access_level: Optional[str] = None,
     __args__ = dict()
     __args__['accessLevel'] = access_level
     __args__['compartmentIdInSubtree'] = compartment_id_in_subtree
+    __args__['fields'] = fields
     __args__['filters'] = filters
     __args__['findingKey'] = finding_key
     __args__['isTopFinding'] = is_top_finding
     __args__['references'] = references
+    __args__['scimQuery'] = scim_query
     __args__['securityAssessmentId'] = security_assessment_id
     __args__['severity'] = severity
     __args__['state'] = state
@@ -212,22 +239,26 @@ def get_security_assessment_findings(access_level: Optional[str] = None,
     return AwaitableGetSecurityAssessmentFindingsResult(
         access_level=pulumi.get(__ret__, 'access_level'),
         compartment_id_in_subtree=pulumi.get(__ret__, 'compartment_id_in_subtree'),
+        fields=pulumi.get(__ret__, 'fields'),
         filters=pulumi.get(__ret__, 'filters'),
         finding_key=pulumi.get(__ret__, 'finding_key'),
         findings=pulumi.get(__ret__, 'findings'),
         id=pulumi.get(__ret__, 'id'),
         is_top_finding=pulumi.get(__ret__, 'is_top_finding'),
         references=pulumi.get(__ret__, 'references'),
+        scim_query=pulumi.get(__ret__, 'scim_query'),
         security_assessment_id=pulumi.get(__ret__, 'security_assessment_id'),
         severity=pulumi.get(__ret__, 'severity'),
         state=pulumi.get(__ret__, 'state'),
         target_id=pulumi.get(__ret__, 'target_id'))
 def get_security_assessment_findings_output(access_level: Optional[pulumi.Input[Optional[str]]] = None,
                                             compartment_id_in_subtree: Optional[pulumi.Input[Optional[bool]]] = None,
+                                            fields: Optional[pulumi.Input[Optional[Sequence[str]]]] = None,
                                             filters: Optional[pulumi.Input[Optional[Sequence[Union['GetSecurityAssessmentFindingsFilterArgs', 'GetSecurityAssessmentFindingsFilterArgsDict']]]]] = None,
                                             finding_key: Optional[pulumi.Input[Optional[str]]] = None,
                                             is_top_finding: Optional[pulumi.Input[Optional[bool]]] = None,
                                             references: Optional[pulumi.Input[Optional[str]]] = None,
+                                            scim_query: Optional[pulumi.Input[Optional[str]]] = None,
                                             security_assessment_id: Optional[pulumi.Input[str]] = None,
                                             severity: Optional[pulumi.Input[Optional[str]]] = None,
                                             state: Optional[pulumi.Input[Optional[str]]] = None,
@@ -241,9 +272,14 @@ def get_security_assessment_findings_output(access_level: Optional[pulumi.Input[
 
     :param str access_level: Valid values are RESTRICTED and ACCESSIBLE. Default is RESTRICTED. Setting this to ACCESSIBLE returns only those compartments for which the user has INSPECT permissions directly or indirectly (permissions can be on a resource in a subcompartment). When set to RESTRICTED permissions are checked and no partial results are displayed.
     :param bool compartment_id_in_subtree: Default is false. When set to true, the hierarchy of compartments is traversed and all compartments and subcompartments in the tenancy are returned. Depends on the 'accessLevel' setting.
+    :param Sequence[str] fields: Specifies a subset of fields to be returned in the response.
     :param str finding_key: Each finding in security assessment has an associated key (think of key as a finding's name). For a given finding, the key will be the same across targets. The user can use these keys to filter the findings.
     :param bool is_top_finding: A filter to return only the findings that are marked as top findings.
-    :param str references: An optional filter to return only findings containing the specified reference.
+    :param str references: An optional filter to return only findings that match the specified reference.
+    :param str scim_query: The scimQuery query parameter accepts filter expressions that use the syntax described in Section 3.2.2.2 of the System for Cross-Domain Identity Management (SCIM) specification, which is available at [RFC3339](https://tools.ietf.org/html/draft-ietf-scim-api-12). In SCIM filtering expressions, text, date, and time values must be enclosed in quotation marks, with date and time values using ISO-8601 format. (Numeric and boolean values should not be quoted.)
+           
+           **Example:** | scimQuery=(severity eq 'high') and (targetId eq 'target_1') scimQuery=(category eq "Users") and (targetId eq "target_1") scimQuery=(reference eq 'CIS') and (targetId eq 'target_1')
+           Supported fields: severity findingKey reference targetId isTopFinding title category remarks details summary isRiskModified
     :param str security_assessment_id: The OCID of the security assessment.
     :param str severity: A filter to return only findings of a particular risk level.
     :param str state: A filter to return only the findings that match the specified lifecycle states.
@@ -252,10 +288,12 @@ def get_security_assessment_findings_output(access_level: Optional[pulumi.Input[
     __args__ = dict()
     __args__['accessLevel'] = access_level
     __args__['compartmentIdInSubtree'] = compartment_id_in_subtree
+    __args__['fields'] = fields
     __args__['filters'] = filters
     __args__['findingKey'] = finding_key
     __args__['isTopFinding'] = is_top_finding
     __args__['references'] = references
+    __args__['scimQuery'] = scim_query
     __args__['securityAssessmentId'] = security_assessment_id
     __args__['severity'] = severity
     __args__['state'] = state
@@ -265,12 +303,14 @@ def get_security_assessment_findings_output(access_level: Optional[pulumi.Input[
     return __ret__.apply(lambda __response__: GetSecurityAssessmentFindingsResult(
         access_level=pulumi.get(__response__, 'access_level'),
         compartment_id_in_subtree=pulumi.get(__response__, 'compartment_id_in_subtree'),
+        fields=pulumi.get(__response__, 'fields'),
         filters=pulumi.get(__response__, 'filters'),
         finding_key=pulumi.get(__response__, 'finding_key'),
         findings=pulumi.get(__response__, 'findings'),
         id=pulumi.get(__response__, 'id'),
         is_top_finding=pulumi.get(__response__, 'is_top_finding'),
         references=pulumi.get(__response__, 'references'),
+        scim_query=pulumi.get(__response__, 'scim_query'),
         security_assessment_id=pulumi.get(__response__, 'security_assessment_id'),
         severity=pulumi.get(__response__, 'severity'),
         state=pulumi.get(__response__, 'state'),