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

import copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities

__all__ = [
    'AuditPolicyAuditConditionArgs',
    'AuditPolicyAuditConditionEnableConditionArgs',
    'AuditPolicyAuditSpecificationArgs',
    'AuditProfileAuditTrailArgs',
    'DataSafeConfigurationGlobalSettingArgs',
    'DiscoveryJobsResultModifiedAttributeArgs',
    'LibraryMasingFormatFormatEntryArgs',
    'MaskingPoliciesMaskingColumnMaskingFormatArgs',
    'MaskingPoliciesMaskingColumnMaskingFormatFormatEntryArgs',
    'MaskingPolicyColumnSourceArgs',
    'ReportDefinitionColumnFilterArgs',
    'ReportDefinitionColumnInfoArgs',
    'ReportDefinitionColumnSortingArgs',
    'ReportDefinitionSummaryArgs',
    'SecurityAssessmentStatisticArgs',
    'SecurityAssessmentStatisticAdvisoryArgs',
    'SecurityAssessmentStatisticEvaluateArgs',
    'SecurityAssessmentStatisticHighRiskArgs',
    'SecurityAssessmentStatisticLowRiskArgs',
    'SecurityAssessmentStatisticMediumRiskArgs',
    'SecurityAssessmentStatisticPassArgs',
    'TargetDatabaseConnectionOptionArgs',
    'TargetDatabaseCredentialsArgs',
    'TargetDatabaseDatabaseDetailsArgs',
    'TargetDatabaseTlsConfigArgs',
    'UserAssessmentIgnoredTargetArgs',
    'GetAlertPoliciesFilterArgs',
    'GetAlertPolicyRulesFilterArgs',
    'GetAlertsFilterArgs',
    'GetAuditArchiveRetrievalsFilterArgs',
    'GetAuditEventsFilterArgs',
    'GetAuditPoliciesFilterArgs',
    'GetAuditProfileAvailableAuditVolumesFilterArgs',
    'GetAuditProfileCollectedAuditVolumesFilterArgs',
    'GetAuditProfilesFilterArgs',
    'GetAuditTrailsFilterArgs',
    'GetDataSafePrivateEndpointsFilterArgs',
    'GetDiscoveryAnalyticsFilterArgs',
    'GetDiscoveryJobsResultsFilterArgs',
    'GetLibraryMaskingFormatsFilterArgs',
    'GetListUserGrantsFilterArgs',
    'GetMaskingAnalyticsFilterArgs',
    'GetMaskingPoliciesFilterArgs',
    'GetMaskingPoliciesMaskingColumnsFilterArgs',
    'GetMaskingPolicyMaskingObjectsFilterArgs',
    'GetMaskingPolicyMaskingSchemasFilterArgs',
    'GetMaskingReportMaskedColumnsFilterArgs',
    'GetMaskingReportsFilterArgs',
    'GetOnpremConnectorsFilterArgs',
    'GetReportDefinitionsFilterArgs',
    'GetReportsFilterArgs',
    'GetSdmMaskingPolicyDifferenceDifferenceColumnsFilterArgs',
    'GetSdmMaskingPolicyDifferencesFilterArgs',
    'GetSecurityAssessmentFindingFilterArgs',
    'GetSecurityAssessmentFindingsFilterArgs',
    'GetSecurityAssessmentsFilterArgs',
    'GetSensitiveDataModelSensitiveObjectsFilterArgs',
    'GetSensitiveDataModelSensitiveSchemasFilterArgs',
    'GetSensitiveDataModelsFilterArgs',
    'GetSensitiveDataModelsSensitiveColumnsFilterArgs',
    'GetSensitiveTypesFilterArgs',
    'GetTargetAlertPolicyAssociationsFilterArgs',
    'GetTargetDatabaseRoleFilterArgs',
    'GetTargetDatabaseRolesFilterArgs',
    'GetTargetDatabasesColumnsFilterArgs',
    'GetTargetDatabasesFilterArgs',
    'GetTargetDatabasesSchemasFilterArgs',
    'GetTargetDatabasesTablesFilterArgs',
    'GetUserAssessmentProfileAnalyticsFilterArgs',
    'GetUserAssessmentProfilesFilterArgs',
    'GetUserAssessmentUserAnalyticsFilterArgs',
    'GetUserAssessmentUsersFilterArgs',
    'GetUserAssessmentsFilterArgs',
]

@pulumi.input_type
class AuditPolicyAuditConditionArgs:
    def __init__(__self__, *,
                 audit_policy_name: Optional[pulumi.Input[str]] = None,
                 enable_conditions: Optional[pulumi.Input[Sequence[pulumi.Input['AuditPolicyAuditConditionEnableConditionArgs']]]] = None,
                 is_data_safe_service_account_audited: Optional[pulumi.Input[bool]] = None,
                 is_priv_users_managed_by_data_safe: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] audit_policy_name: Indicates the audit policy name. Refer to the [documentation](https://docs.oracle.com/en/cloud/paas/data-safe/udscs/audit-policies.html#GUID-361A9A9A-7C21-4F5A-8945-9B3A0C472827) for seeded audit policy names. For custom policies, refer to the user-defined policy name created in the target database.
        :param pulumi.Input[Sequence[pulumi.Input['AuditPolicyAuditConditionEnableConditionArgs']]] enable_conditions: Indicates the users/roles in the target database for which the audit policy is enforced, and the success/failure event condition to generate the audit event..
        :param pulumi.Input[bool] is_data_safe_service_account_audited: Indicates whether the Data Safe user activity on the target database will be audited by the policy.
        :param pulumi.Input[bool] is_priv_users_managed_by_data_safe: Indicates whether the privileged user list is managed by Data Safe.
        """
        if audit_policy_name is not None:
            pulumi.set(__self__, "audit_policy_name", audit_policy_name)
        if enable_conditions is not None:
            pulumi.set(__self__, "enable_conditions", enable_conditions)
        if is_data_safe_service_account_audited is not None:
            pulumi.set(__self__, "is_data_safe_service_account_audited", is_data_safe_service_account_audited)
        if is_priv_users_managed_by_data_safe is not None:
            pulumi.set(__self__, "is_priv_users_managed_by_data_safe", is_priv_users_managed_by_data_safe)

    @property
    @pulumi.getter(name="auditPolicyName")
    def audit_policy_name(self) -> Optional[pulumi.Input[str]]:
        """
        Indicates the audit policy name. Refer to the [documentation](https://docs.oracle.com/en/cloud/paas/data-safe/udscs/audit-policies.html#GUID-361A9A9A-7C21-4F5A-8945-9B3A0C472827) for seeded audit policy names. For custom policies, refer to the user-defined policy name created in the target database.
        """
        return pulumi.get(self, "audit_policy_name")

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

    @property
    @pulumi.getter(name="enableConditions")
    def enable_conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AuditPolicyAuditConditionEnableConditionArgs']]]]:
        """
        Indicates the users/roles in the target database for which the audit policy is enforced, and the success/failure event condition to generate the audit event..
        """
        return pulumi.get(self, "enable_conditions")

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

    @property
    @pulumi.getter(name="isDataSafeServiceAccountAudited")
    def is_data_safe_service_account_audited(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether the Data Safe user activity on the target database will be audited by the policy.
        """
        return pulumi.get(self, "is_data_safe_service_account_audited")

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

    @property
    @pulumi.getter(name="isPrivUsersManagedByDataSafe")
    def is_priv_users_managed_by_data_safe(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether the privileged user list is managed by Data Safe.
        """
        return pulumi.get(self, "is_priv_users_managed_by_data_safe")

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


@pulumi.input_type
class AuditPolicyAuditConditionEnableConditionArgs:
    def __init__(__self__, *,
                 entity_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 entity_selection: Optional[pulumi.Input[str]] = None,
                 entity_type: Optional[pulumi.Input[str]] = None,
                 operation_status: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] entity_names: List of users or roles that the policy must be enabled for.
        :param pulumi.Input[str] entity_selection: The entity include or exclude selection.
        :param pulumi.Input[str] entity_type: The entity type that the policy must be enabled for.
        :param pulumi.Input[str] operation_status: The operation status that the policy must be enabled for.
        """
        if entity_names is not None:
            pulumi.set(__self__, "entity_names", entity_names)
        if entity_selection is not None:
            pulumi.set(__self__, "entity_selection", entity_selection)
        if entity_type is not None:
            pulumi.set(__self__, "entity_type", entity_type)
        if operation_status is not None:
            pulumi.set(__self__, "operation_status", operation_status)

    @property
    @pulumi.getter(name="entityNames")
    def entity_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of users or roles that the policy must be enabled for.
        """
        return pulumi.get(self, "entity_names")

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

    @property
    @pulumi.getter(name="entitySelection")
    def entity_selection(self) -> Optional[pulumi.Input[str]]:
        """
        The entity include or exclude selection.
        """
        return pulumi.get(self, "entity_selection")

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

    @property
    @pulumi.getter(name="entityType")
    def entity_type(self) -> Optional[pulumi.Input[str]]:
        """
        The entity type that the policy must be enabled for.
        """
        return pulumi.get(self, "entity_type")

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

    @property
    @pulumi.getter(name="operationStatus")
    def operation_status(self) -> Optional[pulumi.Input[str]]:
        """
        The operation status that the policy must be enabled for.
        """
        return pulumi.get(self, "operation_status")

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


@pulumi.input_type
class AuditPolicyAuditSpecificationArgs:
    def __init__(__self__, *,
                 audit_policy_category: Optional[pulumi.Input[str]] = None,
                 audit_policy_name: Optional[pulumi.Input[str]] = None,
                 database_policy_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 enable_status: Optional[pulumi.Input[str]] = None,
                 enabled_entities: Optional[pulumi.Input[str]] = None,
                 is_created: Optional[pulumi.Input[bool]] = None,
                 is_enabled_for_all_users: Optional[pulumi.Input[bool]] = None,
                 is_seeded_in_data_safe: Optional[pulumi.Input[bool]] = None,
                 is_seeded_in_target: Optional[pulumi.Input[bool]] = None,
                 is_view_only: Optional[pulumi.Input[bool]] = None,
                 partially_enabled_msg: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] audit_policy_category: The category to which the audit policy belongs.
        :param pulumi.Input[str] audit_policy_name: Indicates the audit policy name. Refer to the [documentation](https://docs.oracle.com/en/cloud/paas/data-safe/udscs/audit-policies.html#GUID-361A9A9A-7C21-4F5A-8945-9B3A0C472827) for seeded audit policy names. For custom policies, refer to the user-defined policy name created in the target database.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] database_policy_names: Indicates the names of corresponding database policy ( or policies) in the target database.
        :param pulumi.Input[str] enable_status: Indicates whether the policy has been enabled, disabled or partially enabled in the target database. The status is PARTIALLY_ENABLED if any of the constituent database audit policies is not enabled.
        :param pulumi.Input[str] enabled_entities: Indicates on whom the audit policy is enabled.
        :param pulumi.Input[bool] is_created: Indicates whether the policy is already created on the target database.
        :param pulumi.Input[bool] is_enabled_for_all_users: Indicates whether the policy by default is enabled for all users with no flexibility to alter the enablement conditions.
        :param pulumi.Input[bool] is_seeded_in_data_safe: Indicates whether the audit policy is one of the seeded policies provided by Oracle Data Safe.
        :param pulumi.Input[bool] is_seeded_in_target: Indicates whether the audit policy is one of the predefined policies provided by Oracle Database.
        :param pulumi.Input[bool] is_view_only: Indicates whether the audit policy is available for provisioning/ de-provisioning from Oracle Data Safe, or is only available for displaying the current provisioning status from the target.
        :param pulumi.Input[str] partially_enabled_msg: Provides information about the policy that has been only partially enabled.
        """
        if audit_policy_category is not None:
            pulumi.set(__self__, "audit_policy_category", audit_policy_category)
        if audit_policy_name is not None:
            pulumi.set(__self__, "audit_policy_name", audit_policy_name)
        if database_policy_names is not None:
            pulumi.set(__self__, "database_policy_names", database_policy_names)
        if enable_status is not None:
            pulumi.set(__self__, "enable_status", enable_status)
        if enabled_entities is not None:
            pulumi.set(__self__, "enabled_entities", enabled_entities)
        if is_created is not None:
            pulumi.set(__self__, "is_created", is_created)
        if is_enabled_for_all_users is not None:
            pulumi.set(__self__, "is_enabled_for_all_users", is_enabled_for_all_users)
        if is_seeded_in_data_safe is not None:
            pulumi.set(__self__, "is_seeded_in_data_safe", is_seeded_in_data_safe)
        if is_seeded_in_target is not None:
            pulumi.set(__self__, "is_seeded_in_target", is_seeded_in_target)
        if is_view_only is not None:
            pulumi.set(__self__, "is_view_only", is_view_only)
        if partially_enabled_msg is not None:
            pulumi.set(__self__, "partially_enabled_msg", partially_enabled_msg)

    @property
    @pulumi.getter(name="auditPolicyCategory")
    def audit_policy_category(self) -> Optional[pulumi.Input[str]]:
        """
        The category to which the audit policy belongs.
        """
        return pulumi.get(self, "audit_policy_category")

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

    @property
    @pulumi.getter(name="auditPolicyName")
    def audit_policy_name(self) -> Optional[pulumi.Input[str]]:
        """
        Indicates the audit policy name. Refer to the [documentation](https://docs.oracle.com/en/cloud/paas/data-safe/udscs/audit-policies.html#GUID-361A9A9A-7C21-4F5A-8945-9B3A0C472827) for seeded audit policy names. For custom policies, refer to the user-defined policy name created in the target database.
        """
        return pulumi.get(self, "audit_policy_name")

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

    @property
    @pulumi.getter(name="databasePolicyNames")
    def database_policy_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Indicates the names of corresponding database policy ( or policies) in the target database.
        """
        return pulumi.get(self, "database_policy_names")

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

    @property
    @pulumi.getter(name="enableStatus")
    def enable_status(self) -> Optional[pulumi.Input[str]]:
        """
        Indicates whether the policy has been enabled, disabled or partially enabled in the target database. The status is PARTIALLY_ENABLED if any of the constituent database audit policies is not enabled.
        """
        return pulumi.get(self, "enable_status")

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

    @property
    @pulumi.getter(name="enabledEntities")
    def enabled_entities(self) -> Optional[pulumi.Input[str]]:
        """
        Indicates on whom the audit policy is enabled.
        """
        return pulumi.get(self, "enabled_entities")

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

    @property
    @pulumi.getter(name="isCreated")
    def is_created(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether the policy is already created on the target database.
        """
        return pulumi.get(self, "is_created")

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

    @property
    @pulumi.getter(name="isEnabledForAllUsers")
    def is_enabled_for_all_users(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether the policy by default is enabled for all users with no flexibility to alter the enablement conditions.
        """
        return pulumi.get(self, "is_enabled_for_all_users")

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

    @property
    @pulumi.getter(name="isSeededInDataSafe")
    def is_seeded_in_data_safe(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether the audit policy is one of the seeded policies provided by Oracle Data Safe.
        """
        return pulumi.get(self, "is_seeded_in_data_safe")

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

    @property
    @pulumi.getter(name="isSeededInTarget")
    def is_seeded_in_target(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether the audit policy is one of the predefined policies provided by Oracle Database.
        """
        return pulumi.get(self, "is_seeded_in_target")

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

    @property
    @pulumi.getter(name="isViewOnly")
    def is_view_only(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether the audit policy is available for provisioning/ de-provisioning from Oracle Data Safe, or is only available for displaying the current provisioning status from the target.
        """
        return pulumi.get(self, "is_view_only")

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

    @property
    @pulumi.getter(name="partiallyEnabledMsg")
    def partially_enabled_msg(self) -> Optional[pulumi.Input[str]]:
        """
        Provides information about the policy that has been only partially enabled.
        """
        return pulumi.get(self, "partially_enabled_msg")

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


@pulumi.input_type
class AuditProfileAuditTrailArgs:
    def __init__(__self__, *,
                 audit_collection_start_time: Optional[pulumi.Input[str]] = None,
                 audit_profile_id: Optional[pulumi.Input[str]] = None,
                 compartment_id: Optional[pulumi.Input[str]] = None,
                 defined_tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 display_name: Optional[pulumi.Input[str]] = None,
                 freeform_tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 id: Optional[pulumi.Input[str]] = None,
                 is_auto_purge_enabled: Optional[pulumi.Input[bool]] = None,
                 lifecycle_details: Optional[pulumi.Input[str]] = None,
                 state: Optional[pulumi.Input[str]] = None,
                 status: Optional[pulumi.Input[str]] = None,
                 system_tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 target_id: Optional[pulumi.Input[str]] = None,
                 time_created: Optional[pulumi.Input[str]] = None,
                 time_last_collected: Optional[pulumi.Input[str]] = None,
                 time_updated: Optional[pulumi.Input[str]] = None,
                 trail_location: Optional[pulumi.Input[str]] = None,
                 work_request_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] audit_collection_start_time: The date from which the audit trail must start collecting data, in the format defined by RFC3339.
        :param pulumi.Input[str] audit_profile_id: The OCID of the audit.
        :param pulumi.Input[str] compartment_id: (Updatable) The OCID of the compartment that contains the audit.
        :param pulumi.Input[Mapping[str, Any]] defined_tags: (Updatable) Defined 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)  Example: `{"Operations.CostCenter": "42"}`
        :param pulumi.Input[str] description: (Updatable) The description of the audit profile.
        :param pulumi.Input[str] display_name: (Updatable) The display name of the audit profile. The name does not have to be unique, and it's changeable.
        :param pulumi.Input[Mapping[str, Any]] freeform_tags: (Updatable) Free-form tags for this resource. Each tag is a simple key-value pair with no predefined name, type, or namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm)  Example: `{"Department": "Finance"}`
        :param pulumi.Input[str] id: The OCID of the audit profile.
        :param pulumi.Input[bool] is_auto_purge_enabled: Indicates if auto purge is enabled on the target database, which helps delete audit data in the target database every seven days so that the database's audit trail does not become too large.
        :param pulumi.Input[str] lifecycle_details: Details about the current state of the audit profile in Data Safe.
        :param pulumi.Input[str] state: The current state of the audit profile.
        :param pulumi.Input[str] status: The current sub-state of the audit trail.
        :param pulumi.Input[Mapping[str, Any]] system_tags: System tags for this resource. Each key is predefined and scoped to a namespace. For more information, see Resource Tags. Example: `{"orcl-cloud.free-tier-retained": "true"}`
        :param pulumi.Input[str] target_id: The OCID of the Data Safe target for which the audit profile is created.
        :param pulumi.Input[str] time_created: The date and time the audit profile was created, in the format defined by RFC3339.
        :param pulumi.Input[str] time_last_collected: The date and time until when the audit events were collected from the target database by the Data Safe audit trail  collection process, in the format defined by RFC3339.
        :param pulumi.Input[str] time_updated: The date and time the audit profile was updated, in the format defined by RFC3339.
        :param pulumi.Input[str] trail_location: An audit trail location represents the source of audit records that provides documentary evidence of the sequence of activities in the target database.
        :param pulumi.Input[str] work_request_id: The OCID of the workrequest for audit trail which collects audit records.
        """
        if audit_collection_start_time is not None:
            pulumi.set(__self__, "audit_collection_start_time", audit_collection_start_time)
        if audit_profile_id is not None:
            pulumi.set(__self__, "audit_profile_id", audit_profile_id)
        if compartment_id is not None:
            pulumi.set(__self__, "compartment_id", compartment_id)
        if defined_tags is not None:
            pulumi.set(__self__, "defined_tags", defined_tags)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if freeform_tags is not None:
            pulumi.set(__self__, "freeform_tags", freeform_tags)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if is_auto_purge_enabled is not None:
            pulumi.set(__self__, "is_auto_purge_enabled", is_auto_purge_enabled)
        if lifecycle_details is not None:
            pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        if state is not None:
            pulumi.set(__self__, "state", state)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if system_tags is not None:
            pulumi.set(__self__, "system_tags", system_tags)
        if target_id is not None:
            pulumi.set(__self__, "target_id", target_id)
        if time_created is not None:
            pulumi.set(__self__, "time_created", time_created)
        if time_last_collected is not None:
            pulumi.set(__self__, "time_last_collected", time_last_collected)
        if time_updated is not None:
            pulumi.set(__self__, "time_updated", time_updated)
        if trail_location is not None:
            pulumi.set(__self__, "trail_location", trail_location)
        if work_request_id is not None:
            pulumi.set(__self__, "work_request_id", work_request_id)

    @property
    @pulumi.getter(name="auditCollectionStartTime")
    def audit_collection_start_time(self) -> Optional[pulumi.Input[str]]:
        """
        The date from which the audit trail must start collecting data, in the format defined by RFC3339.
        """
        return pulumi.get(self, "audit_collection_start_time")

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

    @property
    @pulumi.getter(name="auditProfileId")
    def audit_profile_id(self) -> Optional[pulumi.Input[str]]:
        """
        The OCID of the audit.
        """
        return pulumi.get(self, "audit_profile_id")

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

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The OCID of the compartment that contains the audit.
        """
        return pulumi.get(self, "compartment_id")

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

    @property
    @pulumi.getter(name="definedTags")
    def defined_tags(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        (Updatable) Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm)  Example: `{"Operations.CostCenter": "42"}`
        """
        return pulumi.get(self, "defined_tags")

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

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

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The display name of the audit profile. The name does not have to be unique, and it's changeable.
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter(name="freeformTags")
    def freeform_tags(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        (Updatable) Free-form tags for this resource. Each tag is a simple key-value pair with no predefined name, type, or namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm)  Example: `{"Department": "Finance"}`
        """
        return pulumi.get(self, "freeform_tags")

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

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[str]]:
        """
        The OCID of the audit profile.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="isAutoPurgeEnabled")
    def is_auto_purge_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates if auto purge is enabled on the target database, which helps delete audit data in the target database every seven days so that the database's audit trail does not become too large.
        """
        return pulumi.get(self, "is_auto_purge_enabled")

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

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> Optional[pulumi.Input[str]]:
        """
        Details about the current state of the audit profile in Data Safe.
        """
        return pulumi.get(self, "lifecycle_details")

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

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

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

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

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

    @property
    @pulumi.getter(name="systemTags")
    def system_tags(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        System tags for this resource. Each key is predefined and scoped to a namespace. For more information, see Resource Tags. Example: `{"orcl-cloud.free-tier-retained": "true"}`
        """
        return pulumi.get(self, "system_tags")

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

    @property
    @pulumi.getter(name="targetId")
    def target_id(self) -> Optional[pulumi.Input[str]]:
        """
        The OCID of the Data Safe target for which the audit profile is created.
        """
        return pulumi.get(self, "target_id")

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

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

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

    @property
    @pulumi.getter(name="timeLastCollected")
    def time_last_collected(self) -> Optional[pulumi.Input[str]]:
        """
        The date and time until when the audit events were collected from the target database by the Data Safe audit trail  collection process, in the format defined by RFC3339.
        """
        return pulumi.get(self, "time_last_collected")

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

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

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

    @property
    @pulumi.getter(name="trailLocation")
    def trail_location(self) -> Optional[pulumi.Input[str]]:
        """
        An audit trail location represents the source of audit records that provides documentary evidence of the sequence of activities in the target database.
        """
        return pulumi.get(self, "trail_location")

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

    @property
    @pulumi.getter(name="workRequestId")
    def work_request_id(self) -> Optional[pulumi.Input[str]]:
        """
        The OCID of the workrequest for audit trail which collects audit records.
        """
        return pulumi.get(self, "work_request_id")

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


@pulumi.input_type
class DataSafeConfigurationGlobalSettingArgs:
    def __init__(__self__, *,
                 is_paid_usage: Optional[pulumi.Input[bool]] = None,
                 offline_retention_period: Optional[pulumi.Input[int]] = None,
                 online_retention_period: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[bool] is_paid_usage: The paid usage option chosen by the customer admin.
        :param pulumi.Input[int] offline_retention_period: The offline retention period in months.
        :param pulumi.Input[int] online_retention_period: The online retention period in months.
        """
        if is_paid_usage is not None:
            pulumi.set(__self__, "is_paid_usage", is_paid_usage)
        if offline_retention_period is not None:
            pulumi.set(__self__, "offline_retention_period", offline_retention_period)
        if online_retention_period is not None:
            pulumi.set(__self__, "online_retention_period", online_retention_period)

    @property
    @pulumi.getter(name="isPaidUsage")
    def is_paid_usage(self) -> Optional[pulumi.Input[bool]]:
        """
        The paid usage option chosen by the customer admin.
        """
        return pulumi.get(self, "is_paid_usage")

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

    @property
    @pulumi.getter(name="offlineRetentionPeriod")
    def offline_retention_period(self) -> Optional[pulumi.Input[int]]:
        """
        The offline retention period in months.
        """
        return pulumi.get(self, "offline_retention_period")

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

    @property
    @pulumi.getter(name="onlineRetentionPeriod")
    def online_retention_period(self) -> Optional[pulumi.Input[int]]:
        """
        The online retention period in months.
        """
        return pulumi.get(self, "online_retention_period")

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


@pulumi.input_type
class DiscoveryJobsResultModifiedAttributeArgs:
    def __init__(__self__, *,
                 app_defined_child_column_keys: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 db_defined_child_column_keys: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] app_defined_child_column_keys: Unique keys identifying the columns that are application-level (non-dictionary) children of the sensitive column.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] db_defined_child_column_keys: Unique keys identifying the columns that are database-level (dictionary-defined) children of the sensitive column.
        """
        if app_defined_child_column_keys is not None:
            pulumi.set(__self__, "app_defined_child_column_keys", app_defined_child_column_keys)
        if db_defined_child_column_keys is not None:
            pulumi.set(__self__, "db_defined_child_column_keys", db_defined_child_column_keys)

    @property
    @pulumi.getter(name="appDefinedChildColumnKeys")
    def app_defined_child_column_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Unique keys identifying the columns that are application-level (non-dictionary) children of the sensitive column.
        """
        return pulumi.get(self, "app_defined_child_column_keys")

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

    @property
    @pulumi.getter(name="dbDefinedChildColumnKeys")
    def db_defined_child_column_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Unique keys identifying the columns that are database-level (dictionary-defined) children of the sensitive column.
        """
        return pulumi.get(self, "db_defined_child_column_keys")

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


@pulumi.input_type
class LibraryMasingFormatFormatEntryArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 column_name: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 end_date: Optional[pulumi.Input[str]] = None,
                 end_length: Optional[pulumi.Input[int]] = None,
                 end_value: Optional[pulumi.Input[float]] = None,
                 fixed_number: Optional[pulumi.Input[float]] = None,
                 fixed_string: Optional[pulumi.Input[str]] = None,
                 grouping_columns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 length: Optional[pulumi.Input[int]] = None,
                 library_masking_format_id: Optional[pulumi.Input[str]] = None,
                 post_processing_function: Optional[pulumi.Input[str]] = None,
                 random_lists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 regular_expression: Optional[pulumi.Input[str]] = None,
                 replace_with: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None,
                 sql_expression: Optional[pulumi.Input[str]] = None,
                 start_date: Optional[pulumi.Input[str]] = None,
                 start_length: Optional[pulumi.Input[int]] = None,
                 start_position: Optional[pulumi.Input[int]] = None,
                 start_value: Optional[pulumi.Input[float]] = None,
                 table_name: Optional[pulumi.Input[str]] = None,
                 user_defined_function: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] type: (Updatable) The type of the format entry.
        :param pulumi.Input[str] column_name: (Updatable) The name of the substitution column.
        :param pulumi.Input[str] description: (Updatable) The description of the format entry.
        :param pulumi.Input[str] end_date: (Updatable) The upper bound of the range within which all the original column values fall. The end date must be greater than or equal to the start date.
        :param pulumi.Input[int] end_length: (Updatable) The maximum number of characters the generated strings should have. It can  be any integer greater than zero, but it must be greater than or equal to  the start length.
        :param pulumi.Input[float] end_value: (Updatable) The upper bound of the range within which random decimal numbers should be generated. It must be greater than or equal to the start value. It supports  input of double type.
        :param pulumi.Input[float] fixed_number: (Updatable) The constant number to be used for masking.
        :param pulumi.Input[str] fixed_string: (Updatable) The constant string to be used for masking.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] grouping_columns: (Updatable) One or more reference columns to be used to group column values so that they can be shuffled within their own group. The grouping columns and  the column to be masked must belong to the same table.
        :param pulumi.Input[int] length: (Updatable) The number of characters that should be there in the substring. It should be an integer and greater than zero.
        :param pulumi.Input[str] library_masking_format_id: (Updatable) The OCID of the library masking format.
        :param pulumi.Input[str] post_processing_function: (Updatable) The post processing function in SCHEMA_NAME.PACKAGE_NAME.FUNCTION_NAME format. It can be a standalone or packaged function, so PACKAGE_NAME is optional.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] random_lists: (Updatable) A comma-separated list of values to be used to replace column values. The list can be of strings, numbers, or dates. The data type of each value in the list must be compatible with the data type of the column. The number of entries in the list cannot be more than 999.
        :param pulumi.Input[str] regular_expression: (Updatable) The regular expression to be used for masking. For data with characters in the ASCII character set, providing a regular expression is optional. However, it  is required if the data contains multi-byte characters. If not provided, an  error is returned when a multi-byte character is found.
               
               In the case of ASCII characters, if a regular expression is not provided,  Deterministic Encryption can encrypt variable-length column values while  preserving their original format.
               
               If a regular expression is provided, the column values in all the rows must match  the regular expression. Deterministic Encryption supports a subset of the regular  expression language. It supports encryption of fixed-length strings, and does not  support * or + syntax of regular expressions. The encrypted values also match the  regular expression, which helps to ensure that the original format is preserved.  If an original value does not match the regular expression, Deterministic Encryption  might not produce a one-to-one mapping. All non-confirming values are mapped to a  single encrypted value, thereby producing a many-to-one mapping.
        :param pulumi.Input[str] replace_with: (Updatable) The value that should be used to replace the data matching the regular  expression. It can be a fixed string, fixed number, null value, or  SQL expression.
        :param pulumi.Input[str] schema_name: (Updatable) The name of the schema that contains the substitution column.
        :param pulumi.Input[str] sql_expression: (Updatable) The SQL expression to be used to generate the masked values. It can  consist of one or more values, operators, and SQL functions that  evaluate to a value. It can also contain substitution columns from  the same table. Specify the substitution columns within percent (%)  symbols.
        :param pulumi.Input[str] start_date: (Updatable) The lower bound of the range within which all the original column values fall. The start date must be less than or equal to the end date.
        :param pulumi.Input[int] start_length: (Updatable) The minimum number of characters the generated strings should have. It can  be any integer greater than zero, but it must be less than or equal to the  end length.
        :param pulumi.Input[int] start_position: (Updatable) The starting position in the original string from where the substring should be extracted. It can be either a positive or a negative integer. If It's negative, the counting starts from the end of the string.
        :param pulumi.Input[float] start_value: (Updatable) The lower bound of the range within which random decimal numbers should  be generated. It must be less than or equal to the end value. It supports  input of double type.
        :param pulumi.Input[str] table_name: (Updatable) The name of the table that contains the substitution column.
        :param pulumi.Input[str] user_defined_function: (Updatable) The user-defined function in SCHEMA_NAME.PACKAGE_NAME.FUNCTION_NAME format.  It can be a standalone or packaged function, so PACKAGE_NAME is optional.
        """
        pulumi.set(__self__, "type", type)
        if column_name is not None:
            pulumi.set(__self__, "column_name", column_name)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if end_date is not None:
            pulumi.set(__self__, "end_date", end_date)
        if end_length is not None:
            pulumi.set(__self__, "end_length", end_length)
        if end_value is not None:
            pulumi.set(__self__, "end_value", end_value)
        if fixed_number is not None:
            pulumi.set(__self__, "fixed_number", fixed_number)
        if fixed_string is not None:
            pulumi.set(__self__, "fixed_string", fixed_string)
        if grouping_columns is not None:
            pulumi.set(__self__, "grouping_columns", grouping_columns)
        if length is not None:
            pulumi.set(__self__, "length", length)
        if library_masking_format_id is not None:
            pulumi.set(__self__, "library_masking_format_id", library_masking_format_id)
        if post_processing_function is not None:
            pulumi.set(__self__, "post_processing_function", post_processing_function)
        if random_lists is not None:
            pulumi.set(__self__, "random_lists", random_lists)
        if regular_expression is not None:
            pulumi.set(__self__, "regular_expression", regular_expression)
        if replace_with is not None:
            pulumi.set(__self__, "replace_with", replace_with)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)
        if sql_expression is not None:
            pulumi.set(__self__, "sql_expression", sql_expression)
        if start_date is not None:
            pulumi.set(__self__, "start_date", start_date)
        if start_length is not None:
            pulumi.set(__self__, "start_length", start_length)
        if start_position is not None:
            pulumi.set(__self__, "start_position", start_position)
        if start_value is not None:
            pulumi.set(__self__, "start_value", start_value)
        if table_name is not None:
            pulumi.set(__self__, "table_name", table_name)
        if user_defined_function is not None:
            pulumi.set(__self__, "user_defined_function", user_defined_function)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        (Updatable) The type of the format entry.
        """
        return pulumi.get(self, "type")

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

    @property
    @pulumi.getter(name="columnName")
    def column_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The name of the substitution column.
        """
        return pulumi.get(self, "column_name")

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

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

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

    @property
    @pulumi.getter(name="endDate")
    def end_date(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The upper bound of the range within which all the original column values fall. The end date must be greater than or equal to the start date.
        """
        return pulumi.get(self, "end_date")

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

    @property
    @pulumi.getter(name="endLength")
    def end_length(self) -> Optional[pulumi.Input[int]]:
        """
        (Updatable) The maximum number of characters the generated strings should have. It can  be any integer greater than zero, but it must be greater than or equal to  the start length.
        """
        return pulumi.get(self, "end_length")

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

    @property
    @pulumi.getter(name="endValue")
    def end_value(self) -> Optional[pulumi.Input[float]]:
        """
        (Updatable) The upper bound of the range within which random decimal numbers should be generated. It must be greater than or equal to the start value. It supports  input of double type.
        """
        return pulumi.get(self, "end_value")

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

    @property
    @pulumi.getter(name="fixedNumber")
    def fixed_number(self) -> Optional[pulumi.Input[float]]:
        """
        (Updatable) The constant number to be used for masking.
        """
        return pulumi.get(self, "fixed_number")

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

    @property
    @pulumi.getter(name="fixedString")
    def fixed_string(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The constant string to be used for masking.
        """
        return pulumi.get(self, "fixed_string")

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

    @property
    @pulumi.getter(name="groupingColumns")
    def grouping_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        (Updatable) One or more reference columns to be used to group column values so that they can be shuffled within their own group. The grouping columns and  the column to be masked must belong to the same table.
        """
        return pulumi.get(self, "grouping_columns")

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

    @property
    @pulumi.getter
    def length(self) -> Optional[pulumi.Input[int]]:
        """
        (Updatable) The number of characters that should be there in the substring. It should be an integer and greater than zero.
        """
        return pulumi.get(self, "length")

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

    @property
    @pulumi.getter(name="libraryMaskingFormatId")
    def library_masking_format_id(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The OCID of the library masking format.
        """
        return pulumi.get(self, "library_masking_format_id")

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

    @property
    @pulumi.getter(name="postProcessingFunction")
    def post_processing_function(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The post processing function in SCHEMA_NAME.PACKAGE_NAME.FUNCTION_NAME format. It can be a standalone or packaged function, so PACKAGE_NAME is optional.
        """
        return pulumi.get(self, "post_processing_function")

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

    @property
    @pulumi.getter(name="randomLists")
    def random_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        (Updatable) A comma-separated list of values to be used to replace column values. The list can be of strings, numbers, or dates. The data type of each value in the list must be compatible with the data type of the column. The number of entries in the list cannot be more than 999.
        """
        return pulumi.get(self, "random_lists")

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

    @property
    @pulumi.getter(name="regularExpression")
    def regular_expression(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The regular expression to be used for masking. For data with characters in the ASCII character set, providing a regular expression is optional. However, it  is required if the data contains multi-byte characters. If not provided, an  error is returned when a multi-byte character is found.

        In the case of ASCII characters, if a regular expression is not provided,  Deterministic Encryption can encrypt variable-length column values while  preserving their original format.

        If a regular expression is provided, the column values in all the rows must match  the regular expression. Deterministic Encryption supports a subset of the regular  expression language. It supports encryption of fixed-length strings, and does not  support * or + syntax of regular expressions. The encrypted values also match the  regular expression, which helps to ensure that the original format is preserved.  If an original value does not match the regular expression, Deterministic Encryption  might not produce a one-to-one mapping. All non-confirming values are mapped to a  single encrypted value, thereby producing a many-to-one mapping.
        """
        return pulumi.get(self, "regular_expression")

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

    @property
    @pulumi.getter(name="replaceWith")
    def replace_with(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The value that should be used to replace the data matching the regular  expression. It can be a fixed string, fixed number, null value, or  SQL expression.
        """
        return pulumi.get(self, "replace_with")

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

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The name of the schema that contains the substitution column.
        """
        return pulumi.get(self, "schema_name")

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

    @property
    @pulumi.getter(name="sqlExpression")
    def sql_expression(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The SQL expression to be used to generate the masked values. It can  consist of one or more values, operators, and SQL functions that  evaluate to a value. It can also contain substitution columns from  the same table. Specify the substitution columns within percent (%)  symbols.
        """
        return pulumi.get(self, "sql_expression")

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

    @property
    @pulumi.getter(name="startDate")
    def start_date(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The lower bound of the range within which all the original column values fall. The start date must be less than or equal to the end date.
        """
        return pulumi.get(self, "start_date")

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

    @property
    @pulumi.getter(name="startLength")
    def start_length(self) -> Optional[pulumi.Input[int]]:
        """
        (Updatable) The minimum number of characters the generated strings should have. It can  be any integer greater than zero, but it must be less than or equal to the  end length.
        """
        return pulumi.get(self, "start_length")

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

    @property
    @pulumi.getter(name="startPosition")
    def start_position(self) -> Optional[pulumi.Input[int]]:
        """
        (Updatable) The starting position in the original string from where the substring should be extracted. It can be either a positive or a negative integer. If It's negative, the counting starts from the end of the string.
        """
        return pulumi.get(self, "start_position")

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

    @property
    @pulumi.getter(name="startValue")
    def start_value(self) -> Optional[pulumi.Input[float]]:
        """
        (Updatable) The lower bound of the range within which random decimal numbers should  be generated. It must be less than or equal to the end value. It supports  input of double type.
        """
        return pulumi.get(self, "start_value")

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

    @property
    @pulumi.getter(name="tableName")
    def table_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The name of the table that contains the substitution column.
        """
        return pulumi.get(self, "table_name")

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

    @property
    @pulumi.getter(name="userDefinedFunction")
    def user_defined_function(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The user-defined function in SCHEMA_NAME.PACKAGE_NAME.FUNCTION_NAME format.  It can be a standalone or packaged function, so PACKAGE_NAME is optional.
        """
        return pulumi.get(self, "user_defined_function")

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


@pulumi.input_type
class MaskingPoliciesMaskingColumnMaskingFormatArgs:
    def __init__(__self__, *,
                 format_entries: pulumi.Input[Sequence[pulumi.Input['MaskingPoliciesMaskingColumnMaskingFormatFormatEntryArgs']]],
                 condition: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['MaskingPoliciesMaskingColumnMaskingFormatFormatEntryArgs']]] format_entries: (Updatable) An array of format entries. The combined output of all the format entries is  used for masking the column data values.
        :param pulumi.Input[str] condition: (Updatable) A condition that must be true for applying the masking format. It can be any valid  SQL construct that can be used in a SQL predicate. It enables you to do  <a href="https://docs.oracle.com/en/cloud/paas/data-safe/udscs/conditional-masking.html">conditional masking</a>  so that you can mask the column data values differently using different masking  formats and the associated conditions.
        :param pulumi.Input[str] description: (Updatable) The description of the format entry.
        """
        pulumi.set(__self__, "format_entries", format_entries)
        if condition is not None:
            pulumi.set(__self__, "condition", condition)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter(name="formatEntries")
    def format_entries(self) -> pulumi.Input[Sequence[pulumi.Input['MaskingPoliciesMaskingColumnMaskingFormatFormatEntryArgs']]]:
        """
        (Updatable) An array of format entries. The combined output of all the format entries is  used for masking the column data values.
        """
        return pulumi.get(self, "format_entries")

    @format_entries.setter
    def format_entries(self, value: pulumi.Input[Sequence[pulumi.Input['MaskingPoliciesMaskingColumnMaskingFormatFormatEntryArgs']]]):
        pulumi.set(self, "format_entries", value)

    @property
    @pulumi.getter
    def condition(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) A condition that must be true for applying the masking format. It can be any valid  SQL construct that can be used in a SQL predicate. It enables you to do  <a href="https://docs.oracle.com/en/cloud/paas/data-safe/udscs/conditional-masking.html">conditional masking</a>  so that you can mask the column data values differently using different masking  formats and the associated conditions.
        """
        return pulumi.get(self, "condition")

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

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

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


@pulumi.input_type
class MaskingPoliciesMaskingColumnMaskingFormatFormatEntryArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 column_name: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 end_date: Optional[pulumi.Input[str]] = None,
                 end_length: Optional[pulumi.Input[int]] = None,
                 end_value: Optional[pulumi.Input[float]] = None,
                 fixed_number: Optional[pulumi.Input[float]] = None,
                 fixed_string: Optional[pulumi.Input[str]] = None,
                 grouping_columns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 length: Optional[pulumi.Input[int]] = None,
                 library_masking_format_id: Optional[pulumi.Input[str]] = None,
                 post_processing_function: Optional[pulumi.Input[str]] = None,
                 random_lists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 regular_expression: Optional[pulumi.Input[str]] = None,
                 replace_with: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None,
                 sql_expression: Optional[pulumi.Input[str]] = None,
                 start_date: Optional[pulumi.Input[str]] = None,
                 start_length: Optional[pulumi.Input[int]] = None,
                 start_position: Optional[pulumi.Input[int]] = None,
                 start_value: Optional[pulumi.Input[float]] = None,
                 table_name: Optional[pulumi.Input[str]] = None,
                 user_defined_function: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] type: (Updatable) The type of the format entry.
        :param pulumi.Input[str] column_name: (Updatable) The name of the substitution column.
        :param pulumi.Input[str] description: (Updatable) The description of the format entry.
        :param pulumi.Input[str] end_date: (Updatable) The upper bound of the range within which all the original column values fall. The end date must be greater than or equal to the start date.
        :param pulumi.Input[int] end_length: (Updatable) The maximum number of characters the generated strings should have. It can  be any integer greater than zero, but it must be greater than or equal to  the start length.
        :param pulumi.Input[float] end_value: (Updatable) The upper bound of the range within which random decimal numbers should be generated. It must be greater than or equal to the start value. It supports  input of double type.
        :param pulumi.Input[float] fixed_number: (Updatable) The constant number to be used for masking.
        :param pulumi.Input[str] fixed_string: (Updatable) The constant string to be used for masking.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] grouping_columns: (Updatable) One or more reference columns to be used to group column values so that they can be shuffled within their own group. The grouping columns and  the column to be masked must belong to the same table.
        :param pulumi.Input[int] length: (Updatable) The number of characters that should be there in the substring. It should be an integer and greater than zero.
        :param pulumi.Input[str] library_masking_format_id: (Updatable) The OCID of the library masking format.
        :param pulumi.Input[str] post_processing_function: (Updatable) The post processing function in SCHEMA_NAME.PACKAGE_NAME.FUNCTION_NAME format. It can be a standalone or packaged function, so PACKAGE_NAME is optional.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] random_lists: (Updatable) A comma-separated list of values to be used to replace column values. The list can be of strings, numbers, or dates. The data type of each value in the list must be compatible with the data type of the column. The number of entries in the list cannot be more than 999.
        :param pulumi.Input[str] regular_expression: (Updatable) The regular expression to be used for masking. For data with characters in the ASCII character set, providing a regular expression is optional. However, it  is required if the data contains multi-byte characters. If not provided, an  error is returned when a multi-byte character is found.
               
               In the case of ASCII characters, if a regular expression is not provided,  Deterministic Encryption can encrypt variable-length column values while  preserving their original format.
               
               If a regular expression is provided, the column values in all the rows must match  the regular expression. Deterministic Encryption supports a subset of the regular  expression language. It supports encryption of fixed-length strings, and does not  support * or + syntax of regular expressions. The encrypted values also match the  regular expression, which helps to ensure that the original format is preserved.  If an original value does not match the regular expression, Deterministic Encryption  might not produce a one-to-one mapping. All non-confirming values are mapped to a  single encrypted value, thereby producing a many-to-one mapping.
        :param pulumi.Input[str] replace_with: (Updatable) The value that should be used to replace the data matching the regular  expression. It can be a fixed string, fixed number, null value, or  SQL expression.
        :param pulumi.Input[str] schema_name: The name of the schema that contains the database column. This attribute cannot be updated for an existing masking column.
        :param pulumi.Input[str] sql_expression: (Updatable) The SQL expression to be used to generate the masked values. It can  consist of one or more values, operators, and SQL functions that  evaluate to a value. It can also contain substitution columns from  the same table. Specify the substitution columns within percent (%)  symbols.
        :param pulumi.Input[str] start_date: (Updatable) The lower bound of the range within which all the original column values fall. The start date must be less than or equal to the end date.
        :param pulumi.Input[int] start_length: (Updatable) The minimum number of characters the generated strings should have. It can  be any integer greater than zero, but it must be less than or equal to the  end length.
        :param pulumi.Input[int] start_position: (Updatable) The starting position in the original string from where the substring should be extracted. It can be either a positive or a negative integer. If It's negative, the counting starts from the end of the string.
        :param pulumi.Input[float] start_value: (Updatable) The lower bound of the range within which random decimal numbers should  be generated. It must be less than or equal to the end value. It supports  input of double type.
        :param pulumi.Input[str] table_name: (Updatable) The name of the table that contains the substitution column.
        :param pulumi.Input[str] user_defined_function: (Updatable) The user-defined function in SCHEMA_NAME.PACKAGE_NAME.FUNCTION_NAME format.  It can be a standalone or packaged function, so PACKAGE_NAME is optional.
        """
        pulumi.set(__self__, "type", type)
        if column_name is not None:
            pulumi.set(__self__, "column_name", column_name)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if end_date is not None:
            pulumi.set(__self__, "end_date", end_date)
        if end_length is not None:
            pulumi.set(__self__, "end_length", end_length)
        if end_value is not None:
            pulumi.set(__self__, "end_value", end_value)
        if fixed_number is not None:
            pulumi.set(__self__, "fixed_number", fixed_number)
        if fixed_string is not None:
            pulumi.set(__self__, "fixed_string", fixed_string)
        if grouping_columns is not None:
            pulumi.set(__self__, "grouping_columns", grouping_columns)
        if length is not None:
            pulumi.set(__self__, "length", length)
        if library_masking_format_id is not None:
            pulumi.set(__self__, "library_masking_format_id", library_masking_format_id)
        if post_processing_function is not None:
            pulumi.set(__self__, "post_processing_function", post_processing_function)
        if random_lists is not None:
            pulumi.set(__self__, "random_lists", random_lists)
        if regular_expression is not None:
            pulumi.set(__self__, "regular_expression", regular_expression)
        if replace_with is not None:
            pulumi.set(__self__, "replace_with", replace_with)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)
        if sql_expression is not None:
            pulumi.set(__self__, "sql_expression", sql_expression)
        if start_date is not None:
            pulumi.set(__self__, "start_date", start_date)
        if start_length is not None:
            pulumi.set(__self__, "start_length", start_length)
        if start_position is not None:
            pulumi.set(__self__, "start_position", start_position)
        if start_value is not None:
            pulumi.set(__self__, "start_value", start_value)
        if table_name is not None:
            pulumi.set(__self__, "table_name", table_name)
        if user_defined_function is not None:
            pulumi.set(__self__, "user_defined_function", user_defined_function)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        (Updatable) The type of the format entry.
        """
        return pulumi.get(self, "type")

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

    @property
    @pulumi.getter(name="columnName")
    def column_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The name of the substitution column.
        """
        return pulumi.get(self, "column_name")

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

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

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

    @property
    @pulumi.getter(name="endDate")
    def end_date(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The upper bound of the range within which all the original column values fall. The end date must be greater than or equal to the start date.
        """
        return pulumi.get(self, "end_date")

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

    @property
    @pulumi.getter(name="endLength")
    def end_length(self) -> Optional[pulumi.Input[int]]:
        """
        (Updatable) The maximum number of characters the generated strings should have. It can  be any integer greater than zero, but it must be greater than or equal to  the start length.
        """
        return pulumi.get(self, "end_length")

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

    @property
    @pulumi.getter(name="endValue")
    def end_value(self) -> Optional[pulumi.Input[float]]:
        """
        (Updatable) The upper bound of the range within which random decimal numbers should be generated. It must be greater than or equal to the start value. It supports  input of double type.
        """
        return pulumi.get(self, "end_value")

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

    @property
    @pulumi.getter(name="fixedNumber")
    def fixed_number(self) -> Optional[pulumi.Input[float]]:
        """
        (Updatable) The constant number to be used for masking.
        """
        return pulumi.get(self, "fixed_number")

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

    @property
    @pulumi.getter(name="fixedString")
    def fixed_string(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The constant string to be used for masking.
        """
        return pulumi.get(self, "fixed_string")

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

    @property
    @pulumi.getter(name="groupingColumns")
    def grouping_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        (Updatable) One or more reference columns to be used to group column values so that they can be shuffled within their own group. The grouping columns and  the column to be masked must belong to the same table.
        """
        return pulumi.get(self, "grouping_columns")

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

    @property
    @pulumi.getter
    def length(self) -> Optional[pulumi.Input[int]]:
        """
        (Updatable) The number of characters that should be there in the substring. It should be an integer and greater than zero.
        """
        return pulumi.get(self, "length")

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

    @property
    @pulumi.getter(name="libraryMaskingFormatId")
    def library_masking_format_id(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The OCID of the library masking format.
        """
        return pulumi.get(self, "library_masking_format_id")

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

    @property
    @pulumi.getter(name="postProcessingFunction")
    def post_processing_function(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The post processing function in SCHEMA_NAME.PACKAGE_NAME.FUNCTION_NAME format. It can be a standalone or packaged function, so PACKAGE_NAME is optional.
        """
        return pulumi.get(self, "post_processing_function")

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

    @property
    @pulumi.getter(name="randomLists")
    def random_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        (Updatable) A comma-separated list of values to be used to replace column values. The list can be of strings, numbers, or dates. The data type of each value in the list must be compatible with the data type of the column. The number of entries in the list cannot be more than 999.
        """
        return pulumi.get(self, "random_lists")

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

    @property
    @pulumi.getter(name="regularExpression")
    def regular_expression(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The regular expression to be used for masking. For data with characters in the ASCII character set, providing a regular expression is optional. However, it  is required if the data contains multi-byte characters. If not provided, an  error is returned when a multi-byte character is found.

        In the case of ASCII characters, if a regular expression is not provided,  Deterministic Encryption can encrypt variable-length column values while  preserving their original format.

        If a regular expression is provided, the column values in all the rows must match  the regular expression. Deterministic Encryption supports a subset of the regular  expression language. It supports encryption of fixed-length strings, and does not  support * or + syntax of regular expressions. The encrypted values also match the  regular expression, which helps to ensure that the original format is preserved.  If an original value does not match the regular expression, Deterministic Encryption  might not produce a one-to-one mapping. All non-confirming values are mapped to a  single encrypted value, thereby producing a many-to-one mapping.
        """
        return pulumi.get(self, "regular_expression")

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

    @property
    @pulumi.getter(name="replaceWith")
    def replace_with(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The value that should be used to replace the data matching the regular  expression. It can be a fixed string, fixed number, null value, or  SQL expression.
        """
        return pulumi.get(self, "replace_with")

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

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the schema that contains the database column. This attribute cannot be updated for an existing masking column.
        """
        return pulumi.get(self, "schema_name")

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

    @property
    @pulumi.getter(name="sqlExpression")
    def sql_expression(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The SQL expression to be used to generate the masked values. It can  consist of one or more values, operators, and SQL functions that  evaluate to a value. It can also contain substitution columns from  the same table. Specify the substitution columns within percent (%)  symbols.
        """
        return pulumi.get(self, "sql_expression")

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

    @property
    @pulumi.getter(name="startDate")
    def start_date(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The lower bound of the range within which all the original column values fall. The start date must be less than or equal to the end date.
        """
        return pulumi.get(self, "start_date")

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

    @property
    @pulumi.getter(name="startLength")
    def start_length(self) -> Optional[pulumi.Input[int]]:
        """
        (Updatable) The minimum number of characters the generated strings should have. It can  be any integer greater than zero, but it must be less than or equal to the  end length.
        """
        return pulumi.get(self, "start_length")

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

    @property
    @pulumi.getter(name="startPosition")
    def start_position(self) -> Optional[pulumi.Input[int]]:
        """
        (Updatable) The starting position in the original string from where the substring should be extracted. It can be either a positive or a negative integer. If It's negative, the counting starts from the end of the string.
        """
        return pulumi.get(self, "start_position")

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

    @property
    @pulumi.getter(name="startValue")
    def start_value(self) -> Optional[pulumi.Input[float]]:
        """
        (Updatable) The lower bound of the range within which random decimal numbers should  be generated. It must be less than or equal to the end value. It supports  input of double type.
        """
        return pulumi.get(self, "start_value")

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

    @property
    @pulumi.getter(name="tableName")
    def table_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The name of the table that contains the substitution column.
        """
        return pulumi.get(self, "table_name")

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

    @property
    @pulumi.getter(name="userDefinedFunction")
    def user_defined_function(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The user-defined function in SCHEMA_NAME.PACKAGE_NAME.FUNCTION_NAME format.  It can be a standalone or packaged function, so PACKAGE_NAME is optional.
        """
        return pulumi.get(self, "user_defined_function")

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


@pulumi.input_type
class MaskingPolicyColumnSourceArgs:
    def __init__(__self__, *,
                 column_source: pulumi.Input[str],
                 sensitive_data_model_id: Optional[pulumi.Input[str]] = None,
                 target_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] column_source: (Updatable) The source of masking columns.
        :param pulumi.Input[str] sensitive_data_model_id: (Updatable) The OCID of the sensitive data model to be associated as the column source with the masking policy.
        :param pulumi.Input[str] target_id: (Updatable) The OCID of the target database to be associated as the column source with the masking policy.
        """
        pulumi.set(__self__, "column_source", column_source)
        if sensitive_data_model_id is not None:
            pulumi.set(__self__, "sensitive_data_model_id", sensitive_data_model_id)
        if target_id is not None:
            pulumi.set(__self__, "target_id", target_id)

    @property
    @pulumi.getter(name="columnSource")
    def column_source(self) -> pulumi.Input[str]:
        """
        (Updatable) The source of masking columns.
        """
        return pulumi.get(self, "column_source")

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

    @property
    @pulumi.getter(name="sensitiveDataModelId")
    def sensitive_data_model_id(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The OCID of the sensitive data model to be associated as the column source with the masking policy.
        """
        return pulumi.get(self, "sensitive_data_model_id")

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

    @property
    @pulumi.getter(name="targetId")
    def target_id(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The OCID of the target database to be associated as the column source with the masking policy.
        """
        return pulumi.get(self, "target_id")

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


@pulumi.input_type
class ReportDefinitionColumnFilterArgs:
    def __init__(__self__, *,
                 expressions: pulumi.Input[Sequence[pulumi.Input[str]]],
                 field_name: pulumi.Input[str],
                 is_enabled: pulumi.Input[bool],
                 is_hidden: pulumi.Input[bool],
                 operator: pulumi.Input[str]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] expressions: (Updatable) An array of expressions based on the operator type. A filter may have one or more expressions.
        :param pulumi.Input[str] field_name: (Updatable) Name of the column that must be sorted.
        :param pulumi.Input[bool] is_enabled: (Updatable) Indicates whether the filter is enabled. Values can either be 'true' or 'false'.
        :param pulumi.Input[bool] is_hidden: (Updatable) Indicates if the summary is hidden. Values can either be 'true' or 'false'.
        :param pulumi.Input[str] operator: (Updatable) Specifies the type of operator that must be applied for example in, eq etc.
        """
        pulumi.set(__self__, "expressions", expressions)
        pulumi.set(__self__, "field_name", field_name)
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "is_hidden", is_hidden)
        pulumi.set(__self__, "operator", operator)

    @property
    @pulumi.getter
    def expressions(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        (Updatable) An array of expressions based on the operator type. A filter may have one or more expressions.
        """
        return pulumi.get(self, "expressions")

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

    @property
    @pulumi.getter(name="fieldName")
    def field_name(self) -> pulumi.Input[str]:
        """
        (Updatable) Name of the column that must be sorted.
        """
        return pulumi.get(self, "field_name")

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

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> pulumi.Input[bool]:
        """
        (Updatable) Indicates whether the filter is enabled. Values can either be 'true' or 'false'.
        """
        return pulumi.get(self, "is_enabled")

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

    @property
    @pulumi.getter(name="isHidden")
    def is_hidden(self) -> pulumi.Input[bool]:
        """
        (Updatable) Indicates if the summary is hidden. Values can either be 'true' or 'false'.
        """
        return pulumi.get(self, "is_hidden")

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

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        """
        (Updatable) Specifies the type of operator that must be applied for example in, eq etc.
        """
        return pulumi.get(self, "operator")

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


@pulumi.input_type
class ReportDefinitionColumnInfoArgs:
    def __init__(__self__, *,
                 display_name: pulumi.Input[str],
                 display_order: pulumi.Input[int],
                 field_name: pulumi.Input[str],
                 is_hidden: pulumi.Input[bool],
                 data_type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] display_name: (Updatable) Specifies the name of the report definition.
        :param pulumi.Input[int] display_order: (Updatable) Specifies the order in which the summary must be displayed.
        :param pulumi.Input[str] field_name: (Updatable) Name of the column that must be sorted.
        :param pulumi.Input[bool] is_hidden: (Updatable) Indicates if the summary is hidden. Values can either be 'true' or 'false'.
        :param pulumi.Input[str] data_type: (Updatable) Specifies the data type of the column.
        """
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "display_order", display_order)
        pulumi.set(__self__, "field_name", field_name)
        pulumi.set(__self__, "is_hidden", is_hidden)
        if data_type is not None:
            pulumi.set(__self__, "data_type", data_type)

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> pulumi.Input[str]:
        """
        (Updatable) Specifies the name of the report definition.
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter(name="displayOrder")
    def display_order(self) -> pulumi.Input[int]:
        """
        (Updatable) Specifies the order in which the summary must be displayed.
        """
        return pulumi.get(self, "display_order")

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

    @property
    @pulumi.getter(name="fieldName")
    def field_name(self) -> pulumi.Input[str]:
        """
        (Updatable) Name of the column that must be sorted.
        """
        return pulumi.get(self, "field_name")

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

    @property
    @pulumi.getter(name="isHidden")
    def is_hidden(self) -> pulumi.Input[bool]:
        """
        (Updatable) Indicates if the summary is hidden. Values can either be 'true' or 'false'.
        """
        return pulumi.get(self, "is_hidden")

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

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

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


@pulumi.input_type
class ReportDefinitionColumnSortingArgs:
    def __init__(__self__, *,
                 field_name: pulumi.Input[str],
                 is_ascending: pulumi.Input[bool],
                 sorting_order: pulumi.Input[int]):
        """
        :param pulumi.Input[str] field_name: (Updatable) Name of the column that must be sorted.
        :param pulumi.Input[bool] is_ascending: (Updatable) Indicates if the column must be sorted in ascending order. Values can either be 'true' or 'false'.
        :param pulumi.Input[int] sorting_order: (Updatable) Indicates the order at which column must be sorted.
        """
        pulumi.set(__self__, "field_name", field_name)
        pulumi.set(__self__, "is_ascending", is_ascending)
        pulumi.set(__self__, "sorting_order", sorting_order)

    @property
    @pulumi.getter(name="fieldName")
    def field_name(self) -> pulumi.Input[str]:
        """
        (Updatable) Name of the column that must be sorted.
        """
        return pulumi.get(self, "field_name")

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

    @property
    @pulumi.getter(name="isAscending")
    def is_ascending(self) -> pulumi.Input[bool]:
        """
        (Updatable) Indicates if the column must be sorted in ascending order. Values can either be 'true' or 'false'.
        """
        return pulumi.get(self, "is_ascending")

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

    @property
    @pulumi.getter(name="sortingOrder")
    def sorting_order(self) -> pulumi.Input[int]:
        """
        (Updatable) Indicates the order at which column must be sorted.
        """
        return pulumi.get(self, "sorting_order")

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


@pulumi.input_type
class ReportDefinitionSummaryArgs:
    def __init__(__self__, *,
                 display_order: pulumi.Input[int],
                 name: pulumi.Input[str],
                 count_of: Optional[pulumi.Input[str]] = None,
                 group_by_field_name: Optional[pulumi.Input[str]] = None,
                 is_hidden: Optional[pulumi.Input[bool]] = None,
                 scim_filter: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] display_order: (Updatable) Specifies the order in which the summary must be displayed.
        :param pulumi.Input[str] name: (Updatable) Name of the report summary.
        :param pulumi.Input[str] count_of: (Updatable) Name of the key or count of object.
        :param pulumi.Input[str] group_by_field_name: (Updatable) A comma-delimited string that specifies the names of the fields by which the records must be aggregated to get the summary.
        :param pulumi.Input[bool] is_hidden: (Updatable) Indicates if the summary is hidden. Values can either be 'true' or 'false'.
        :param pulumi.Input[str] scim_filter: (Updatable) Additional scim filters used to get the specific summary.
               
               
               ** IMPORTANT **
               Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
        """
        pulumi.set(__self__, "display_order", display_order)
        pulumi.set(__self__, "name", name)
        if count_of is not None:
            pulumi.set(__self__, "count_of", count_of)
        if group_by_field_name is not None:
            pulumi.set(__self__, "group_by_field_name", group_by_field_name)
        if is_hidden is not None:
            pulumi.set(__self__, "is_hidden", is_hidden)
        if scim_filter is not None:
            pulumi.set(__self__, "scim_filter", scim_filter)

    @property
    @pulumi.getter(name="displayOrder")
    def display_order(self) -> pulumi.Input[int]:
        """
        (Updatable) Specifies the order in which the summary must be displayed.
        """
        return pulumi.get(self, "display_order")

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

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        (Updatable) Name of the report summary.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter(name="countOf")
    def count_of(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) Name of the key or count of object.
        """
        return pulumi.get(self, "count_of")

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

    @property
    @pulumi.getter(name="groupByFieldName")
    def group_by_field_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) A comma-delimited string that specifies the names of the fields by which the records must be aggregated to get the summary.
        """
        return pulumi.get(self, "group_by_field_name")

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

    @property
    @pulumi.getter(name="isHidden")
    def is_hidden(self) -> Optional[pulumi.Input[bool]]:
        """
        (Updatable) Indicates if the summary is hidden. Values can either be 'true' or 'false'.
        """
        return pulumi.get(self, "is_hidden")

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

    @property
    @pulumi.getter(name="scimFilter")
    def scim_filter(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) Additional scim filters used to get the specific summary.


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

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


@pulumi.input_type
class SecurityAssessmentStatisticArgs:
    def __init__(__self__, *,
                 advisories: Optional[pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticAdvisoryArgs']]]] = None,
                 evaluates: Optional[pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticEvaluateArgs']]]] = None,
                 high_risks: Optional[pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticHighRiskArgs']]]] = None,
                 low_risks: Optional[pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticLowRiskArgs']]]] = None,
                 medium_risks: Optional[pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticMediumRiskArgs']]]] = None,
                 passes: Optional[pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticPassArgs']]]] = None,
                 targets_count: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticAdvisoryArgs']]] advisories: Statistics showing the number of findings with a particular risk level for each category.
        :param pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticEvaluateArgs']]] evaluates: Statistics showing the number of findings with a particular risk level for each category.
        :param pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticHighRiskArgs']]] high_risks: Statistics showing the number of findings with a particular risk level for each category.
        :param pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticLowRiskArgs']]] low_risks: Statistics showing the number of findings with a particular risk level for each category.
        :param pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticMediumRiskArgs']]] medium_risks: Statistics showing the number of findings with a particular risk level for each category.
        :param pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticPassArgs']]] passes: Statistics showing the number of findings with a particular risk level for each category.
        :param pulumi.Input[int] targets_count: The total number of targets in this security assessment.
        """
        if advisories is not None:
            pulumi.set(__self__, "advisories", advisories)
        if evaluates is not None:
            pulumi.set(__self__, "evaluates", evaluates)
        if high_risks is not None:
            pulumi.set(__self__, "high_risks", high_risks)
        if low_risks is not None:
            pulumi.set(__self__, "low_risks", low_risks)
        if medium_risks is not None:
            pulumi.set(__self__, "medium_risks", medium_risks)
        if passes is not None:
            pulumi.set(__self__, "passes", passes)
        if targets_count is not None:
            pulumi.set(__self__, "targets_count", targets_count)

    @property
    @pulumi.getter
    def advisories(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticAdvisoryArgs']]]]:
        """
        Statistics showing the number of findings with a particular risk level for each category.
        """
        return pulumi.get(self, "advisories")

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

    @property
    @pulumi.getter
    def evaluates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticEvaluateArgs']]]]:
        """
        Statistics showing the number of findings with a particular risk level for each category.
        """
        return pulumi.get(self, "evaluates")

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

    @property
    @pulumi.getter(name="highRisks")
    def high_risks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticHighRiskArgs']]]]:
        """
        Statistics showing the number of findings with a particular risk level for each category.
        """
        return pulumi.get(self, "high_risks")

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

    @property
    @pulumi.getter(name="lowRisks")
    def low_risks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticLowRiskArgs']]]]:
        """
        Statistics showing the number of findings with a particular risk level for each category.
        """
        return pulumi.get(self, "low_risks")

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

    @property
    @pulumi.getter(name="mediumRisks")
    def medium_risks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticMediumRiskArgs']]]]:
        """
        Statistics showing the number of findings with a particular risk level for each category.
        """
        return pulumi.get(self, "medium_risks")

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

    @property
    @pulumi.getter
    def passes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticPassArgs']]]]:
        """
        Statistics showing the number of findings with a particular risk level for each category.
        """
        return pulumi.get(self, "passes")

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

    @property
    @pulumi.getter(name="targetsCount")
    def targets_count(self) -> Optional[pulumi.Input[int]]:
        """
        The total number of targets in this security assessment.
        """
        return pulumi.get(self, "targets_count")

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


@pulumi.input_type
class SecurityAssessmentStatisticAdvisoryArgs:
    def __init__(__self__, *,
                 auditing_findings_count: Optional[pulumi.Input[int]] = None,
                 authorization_control_findings_count: Optional[pulumi.Input[int]] = None,
                 data_encryption_findings_count: Optional[pulumi.Input[int]] = None,
                 db_configuration_findings_count: Optional[pulumi.Input[int]] = None,
                 fine_grained_access_control_findings_count: Optional[pulumi.Input[int]] = None,
                 privileges_and_roles_findings_count: Optional[pulumi.Input[int]] = None,
                 targets_count: Optional[pulumi.Input[int]] = None,
                 user_accounts_findings_count: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] auditing_findings_count: The number of findings in the Auditing category.
        :param pulumi.Input[int] authorization_control_findings_count: The number of findings in the Authorization Control category.
        :param pulumi.Input[int] data_encryption_findings_count: The number of findings in the Data Encryption category.
        :param pulumi.Input[int] db_configuration_findings_count: The number of findings in the Database Configuration category.
        :param pulumi.Input[int] fine_grained_access_control_findings_count: The number of findings in the Fine-Grained Access Control category.
        :param pulumi.Input[int] privileges_and_roles_findings_count: The number of findings in the Privileges and Roles category.
        :param pulumi.Input[int] targets_count: The total number of targets in this security assessment.
        :param pulumi.Input[int] user_accounts_findings_count: The number of findings in the User Accounts category.
        """
        if auditing_findings_count is not None:
            pulumi.set(__self__, "auditing_findings_count", auditing_findings_count)
        if authorization_control_findings_count is not None:
            pulumi.set(__self__, "authorization_control_findings_count", authorization_control_findings_count)
        if data_encryption_findings_count is not None:
            pulumi.set(__self__, "data_encryption_findings_count", data_encryption_findings_count)
        if db_configuration_findings_count is not None:
            pulumi.set(__self__, "db_configuration_findings_count", db_configuration_findings_count)
        if fine_grained_access_control_findings_count is not None:
            pulumi.set(__self__, "fine_grained_access_control_findings_count", fine_grained_access_control_findings_count)
        if privileges_and_roles_findings_count is not None:
            pulumi.set(__self__, "privileges_and_roles_findings_count", privileges_and_roles_findings_count)
        if targets_count is not None:
            pulumi.set(__self__, "targets_count", targets_count)
        if user_accounts_findings_count is not None:
            pulumi.set(__self__, "user_accounts_findings_count", user_accounts_findings_count)

    @property
    @pulumi.getter(name="auditingFindingsCount")
    def auditing_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Auditing category.
        """
        return pulumi.get(self, "auditing_findings_count")

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

    @property
    @pulumi.getter(name="authorizationControlFindingsCount")
    def authorization_control_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Authorization Control category.
        """
        return pulumi.get(self, "authorization_control_findings_count")

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

    @property
    @pulumi.getter(name="dataEncryptionFindingsCount")
    def data_encryption_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Data Encryption category.
        """
        return pulumi.get(self, "data_encryption_findings_count")

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

    @property
    @pulumi.getter(name="dbConfigurationFindingsCount")
    def db_configuration_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Database Configuration category.
        """
        return pulumi.get(self, "db_configuration_findings_count")

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

    @property
    @pulumi.getter(name="fineGrainedAccessControlFindingsCount")
    def fine_grained_access_control_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Fine-Grained Access Control category.
        """
        return pulumi.get(self, "fine_grained_access_control_findings_count")

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

    @property
    @pulumi.getter(name="privilegesAndRolesFindingsCount")
    def privileges_and_roles_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Privileges and Roles category.
        """
        return pulumi.get(self, "privileges_and_roles_findings_count")

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

    @property
    @pulumi.getter(name="targetsCount")
    def targets_count(self) -> Optional[pulumi.Input[int]]:
        """
        The total number of targets in this security assessment.
        """
        return pulumi.get(self, "targets_count")

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

    @property
    @pulumi.getter(name="userAccountsFindingsCount")
    def user_accounts_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the User Accounts category.
        """
        return pulumi.get(self, "user_accounts_findings_count")

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


@pulumi.input_type
class SecurityAssessmentStatisticEvaluateArgs:
    def __init__(__self__, *,
                 auditing_findings_count: Optional[pulumi.Input[int]] = None,
                 authorization_control_findings_count: Optional[pulumi.Input[int]] = None,
                 data_encryption_findings_count: Optional[pulumi.Input[int]] = None,
                 db_configuration_findings_count: Optional[pulumi.Input[int]] = None,
                 fine_grained_access_control_findings_count: Optional[pulumi.Input[int]] = None,
                 privileges_and_roles_findings_count: Optional[pulumi.Input[int]] = None,
                 targets_count: Optional[pulumi.Input[int]] = None,
                 user_accounts_findings_count: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] auditing_findings_count: The number of findings in the Auditing category.
        :param pulumi.Input[int] authorization_control_findings_count: The number of findings in the Authorization Control category.
        :param pulumi.Input[int] data_encryption_findings_count: The number of findings in the Data Encryption category.
        :param pulumi.Input[int] db_configuration_findings_count: The number of findings in the Database Configuration category.
        :param pulumi.Input[int] fine_grained_access_control_findings_count: The number of findings in the Fine-Grained Access Control category.
        :param pulumi.Input[int] privileges_and_roles_findings_count: The number of findings in the Privileges and Roles category.
        :param pulumi.Input[int] targets_count: The total number of targets in this security assessment.
        :param pulumi.Input[int] user_accounts_findings_count: The number of findings in the User Accounts category.
        """
        if auditing_findings_count is not None:
            pulumi.set(__self__, "auditing_findings_count", auditing_findings_count)
        if authorization_control_findings_count is not None:
            pulumi.set(__self__, "authorization_control_findings_count", authorization_control_findings_count)
        if data_encryption_findings_count is not None:
            pulumi.set(__self__, "data_encryption_findings_count", data_encryption_findings_count)
        if db_configuration_findings_count is not None:
            pulumi.set(__self__, "db_configuration_findings_count", db_configuration_findings_count)
        if fine_grained_access_control_findings_count is not None:
            pulumi.set(__self__, "fine_grained_access_control_findings_count", fine_grained_access_control_findings_count)
        if privileges_and_roles_findings_count is not None:
            pulumi.set(__self__, "privileges_and_roles_findings_count", privileges_and_roles_findings_count)
        if targets_count is not None:
            pulumi.set(__self__, "targets_count", targets_count)
        if user_accounts_findings_count is not None:
            pulumi.set(__self__, "user_accounts_findings_count", user_accounts_findings_count)

    @property
    @pulumi.getter(name="auditingFindingsCount")
    def auditing_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Auditing category.
        """
        return pulumi.get(self, "auditing_findings_count")

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

    @property
    @pulumi.getter(name="authorizationControlFindingsCount")
    def authorization_control_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Authorization Control category.
        """
        return pulumi.get(self, "authorization_control_findings_count")

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

    @property
    @pulumi.getter(name="dataEncryptionFindingsCount")
    def data_encryption_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Data Encryption category.
        """
        return pulumi.get(self, "data_encryption_findings_count")

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

    @property
    @pulumi.getter(name="dbConfigurationFindingsCount")
    def db_configuration_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Database Configuration category.
        """
        return pulumi.get(self, "db_configuration_findings_count")

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

    @property
    @pulumi.getter(name="fineGrainedAccessControlFindingsCount")
    def fine_grained_access_control_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Fine-Grained Access Control category.
        """
        return pulumi.get(self, "fine_grained_access_control_findings_count")

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

    @property
    @pulumi.getter(name="privilegesAndRolesFindingsCount")
    def privileges_and_roles_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Privileges and Roles category.
        """
        return pulumi.get(self, "privileges_and_roles_findings_count")

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

    @property
    @pulumi.getter(name="targetsCount")
    def targets_count(self) -> Optional[pulumi.Input[int]]:
        """
        The total number of targets in this security assessment.
        """
        return pulumi.get(self, "targets_count")

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

    @property
    @pulumi.getter(name="userAccountsFindingsCount")
    def user_accounts_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the User Accounts category.
        """
        return pulumi.get(self, "user_accounts_findings_count")

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


@pulumi.input_type
class SecurityAssessmentStatisticHighRiskArgs:
    def __init__(__self__, *,
                 auditing_findings_count: Optional[pulumi.Input[int]] = None,
                 authorization_control_findings_count: Optional[pulumi.Input[int]] = None,
                 data_encryption_findings_count: Optional[pulumi.Input[int]] = None,
                 db_configuration_findings_count: Optional[pulumi.Input[int]] = None,
                 fine_grained_access_control_findings_count: Optional[pulumi.Input[int]] = None,
                 privileges_and_roles_findings_count: Optional[pulumi.Input[int]] = None,
                 targets_count: Optional[pulumi.Input[int]] = None,
                 user_accounts_findings_count: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] auditing_findings_count: The number of findings in the Auditing category.
        :param pulumi.Input[int] authorization_control_findings_count: The number of findings in the Authorization Control category.
        :param pulumi.Input[int] data_encryption_findings_count: The number of findings in the Data Encryption category.
        :param pulumi.Input[int] db_configuration_findings_count: The number of findings in the Database Configuration category.
        :param pulumi.Input[int] fine_grained_access_control_findings_count: The number of findings in the Fine-Grained Access Control category.
        :param pulumi.Input[int] privileges_and_roles_findings_count: The number of findings in the Privileges and Roles category.
        :param pulumi.Input[int] targets_count: The total number of targets in this security assessment.
        :param pulumi.Input[int] user_accounts_findings_count: The number of findings in the User Accounts category.
        """
        if auditing_findings_count is not None:
            pulumi.set(__self__, "auditing_findings_count", auditing_findings_count)
        if authorization_control_findings_count is not None:
            pulumi.set(__self__, "authorization_control_findings_count", authorization_control_findings_count)
        if data_encryption_findings_count is not None:
            pulumi.set(__self__, "data_encryption_findings_count", data_encryption_findings_count)
        if db_configuration_findings_count is not None:
            pulumi.set(__self__, "db_configuration_findings_count", db_configuration_findings_count)
        if fine_grained_access_control_findings_count is not None:
            pulumi.set(__self__, "fine_grained_access_control_findings_count", fine_grained_access_control_findings_count)
        if privileges_and_roles_findings_count is not None:
            pulumi.set(__self__, "privileges_and_roles_findings_count", privileges_and_roles_findings_count)
        if targets_count is not None:
            pulumi.set(__self__, "targets_count", targets_count)
        if user_accounts_findings_count is not None:
            pulumi.set(__self__, "user_accounts_findings_count", user_accounts_findings_count)

    @property
    @pulumi.getter(name="auditingFindingsCount")
    def auditing_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Auditing category.
        """
        return pulumi.get(self, "auditing_findings_count")

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

    @property
    @pulumi.getter(name="authorizationControlFindingsCount")
    def authorization_control_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Authorization Control category.
        """
        return pulumi.get(self, "authorization_control_findings_count")

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

    @property
    @pulumi.getter(name="dataEncryptionFindingsCount")
    def data_encryption_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Data Encryption category.
        """
        return pulumi.get(self, "data_encryption_findings_count")

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

    @property
    @pulumi.getter(name="dbConfigurationFindingsCount")
    def db_configuration_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Database Configuration category.
        """
        return pulumi.get(self, "db_configuration_findings_count")

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

    @property
    @pulumi.getter(name="fineGrainedAccessControlFindingsCount")
    def fine_grained_access_control_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Fine-Grained Access Control category.
        """
        return pulumi.get(self, "fine_grained_access_control_findings_count")

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

    @property
    @pulumi.getter(name="privilegesAndRolesFindingsCount")
    def privileges_and_roles_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Privileges and Roles category.
        """
        return pulumi.get(self, "privileges_and_roles_findings_count")

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

    @property
    @pulumi.getter(name="targetsCount")
    def targets_count(self) -> Optional[pulumi.Input[int]]:
        """
        The total number of targets in this security assessment.
        """
        return pulumi.get(self, "targets_count")

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

    @property
    @pulumi.getter(name="userAccountsFindingsCount")
    def user_accounts_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the User Accounts category.
        """
        return pulumi.get(self, "user_accounts_findings_count")

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


@pulumi.input_type
class SecurityAssessmentStatisticLowRiskArgs:
    def __init__(__self__, *,
                 auditing_findings_count: Optional[pulumi.Input[int]] = None,
                 authorization_control_findings_count: Optional[pulumi.Input[int]] = None,
                 data_encryption_findings_count: Optional[pulumi.Input[int]] = None,
                 db_configuration_findings_count: Optional[pulumi.Input[int]] = None,
                 fine_grained_access_control_findings_count: Optional[pulumi.Input[int]] = None,
                 privileges_and_roles_findings_count: Optional[pulumi.Input[int]] = None,
                 targets_count: Optional[pulumi.Input[int]] = None,
                 user_accounts_findings_count: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] auditing_findings_count: The number of findings in the Auditing category.
        :param pulumi.Input[int] authorization_control_findings_count: The number of findings in the Authorization Control category.
        :param pulumi.Input[int] data_encryption_findings_count: The number of findings in the Data Encryption category.
        :param pulumi.Input[int] db_configuration_findings_count: The number of findings in the Database Configuration category.
        :param pulumi.Input[int] fine_grained_access_control_findings_count: The number of findings in the Fine-Grained Access Control category.
        :param pulumi.Input[int] privileges_and_roles_findings_count: The number of findings in the Privileges and Roles category.
        :param pulumi.Input[int] targets_count: The total number of targets in this security assessment.
        :param pulumi.Input[int] user_accounts_findings_count: The number of findings in the User Accounts category.
        """
        if auditing_findings_count is not None:
            pulumi.set(__self__, "auditing_findings_count", auditing_findings_count)
        if authorization_control_findings_count is not None:
            pulumi.set(__self__, "authorization_control_findings_count", authorization_control_findings_count)
        if data_encryption_findings_count is not None:
            pulumi.set(__self__, "data_encryption_findings_count", data_encryption_findings_count)
        if db_configuration_findings_count is not None:
            pulumi.set(__self__, "db_configuration_findings_count", db_configuration_findings_count)
        if fine_grained_access_control_findings_count is not None:
            pulumi.set(__self__, "fine_grained_access_control_findings_count", fine_grained_access_control_findings_count)
        if privileges_and_roles_findings_count is not None:
            pulumi.set(__self__, "privileges_and_roles_findings_count", privileges_and_roles_findings_count)
        if targets_count is not None:
            pulumi.set(__self__, "targets_count", targets_count)
        if user_accounts_findings_count is not None:
            pulumi.set(__self__, "user_accounts_findings_count", user_accounts_findings_count)

    @property
    @pulumi.getter(name="auditingFindingsCount")
    def auditing_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Auditing category.
        """
        return pulumi.get(self, "auditing_findings_count")

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

    @property
    @pulumi.getter(name="authorizationControlFindingsCount")
    def authorization_control_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Authorization Control category.
        """
        return pulumi.get(self, "authorization_control_findings_count")

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

    @property
    @pulumi.getter(name="dataEncryptionFindingsCount")
    def data_encryption_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Data Encryption category.
        """
        return pulumi.get(self, "data_encryption_findings_count")

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

    @property
    @pulumi.getter(name="dbConfigurationFindingsCount")
    def db_configuration_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Database Configuration category.
        """
        return pulumi.get(self, "db_configuration_findings_count")

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

    @property
    @pulumi.getter(name="fineGrainedAccessControlFindingsCount")
    def fine_grained_access_control_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Fine-Grained Access Control category.
        """
        return pulumi.get(self, "fine_grained_access_control_findings_count")

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

    @property
    @pulumi.getter(name="privilegesAndRolesFindingsCount")
    def privileges_and_roles_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Privileges and Roles category.
        """
        return pulumi.get(self, "privileges_and_roles_findings_count")

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

    @property
    @pulumi.getter(name="targetsCount")
    def targets_count(self) -> Optional[pulumi.Input[int]]:
        """
        The total number of targets in this security assessment.
        """
        return pulumi.get(self, "targets_count")

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

    @property
    @pulumi.getter(name="userAccountsFindingsCount")
    def user_accounts_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the User Accounts category.
        """
        return pulumi.get(self, "user_accounts_findings_count")

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


@pulumi.input_type
class SecurityAssessmentStatisticMediumRiskArgs:
    def __init__(__self__, *,
                 auditing_findings_count: Optional[pulumi.Input[int]] = None,
                 authorization_control_findings_count: Optional[pulumi.Input[int]] = None,
                 data_encryption_findings_count: Optional[pulumi.Input[int]] = None,
                 db_configuration_findings_count: Optional[pulumi.Input[int]] = None,
                 fine_grained_access_control_findings_count: Optional[pulumi.Input[int]] = None,
                 privileges_and_roles_findings_count: Optional[pulumi.Input[int]] = None,
                 targets_count: Optional[pulumi.Input[int]] = None,
                 user_accounts_findings_count: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] auditing_findings_count: The number of findings in the Auditing category.
        :param pulumi.Input[int] authorization_control_findings_count: The number of findings in the Authorization Control category.
        :param pulumi.Input[int] data_encryption_findings_count: The number of findings in the Data Encryption category.
        :param pulumi.Input[int] db_configuration_findings_count: The number of findings in the Database Configuration category.
        :param pulumi.Input[int] fine_grained_access_control_findings_count: The number of findings in the Fine-Grained Access Control category.
        :param pulumi.Input[int] privileges_and_roles_findings_count: The number of findings in the Privileges and Roles category.
        :param pulumi.Input[int] targets_count: The total number of targets in this security assessment.
        :param pulumi.Input[int] user_accounts_findings_count: The number of findings in the User Accounts category.
        """
        if auditing_findings_count is not None:
            pulumi.set(__self__, "auditing_findings_count", auditing_findings_count)
        if authorization_control_findings_count is not None:
            pulumi.set(__self__, "authorization_control_findings_count", authorization_control_findings_count)
        if data_encryption_findings_count is not None:
            pulumi.set(__self__, "data_encryption_findings_count", data_encryption_findings_count)
        if db_configuration_findings_count is not None:
            pulumi.set(__self__, "db_configuration_findings_count", db_configuration_findings_count)
        if fine_grained_access_control_findings_count is not None:
            pulumi.set(__self__, "fine_grained_access_control_findings_count", fine_grained_access_control_findings_count)
        if privileges_and_roles_findings_count is not None:
            pulumi.set(__self__, "privileges_and_roles_findings_count", privileges_and_roles_findings_count)
        if targets_count is not None:
            pulumi.set(__self__, "targets_count", targets_count)
        if user_accounts_findings_count is not None:
            pulumi.set(__self__, "user_accounts_findings_count", user_accounts_findings_count)

    @property
    @pulumi.getter(name="auditingFindingsCount")
    def auditing_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Auditing category.
        """
        return pulumi.get(self, "auditing_findings_count")

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

    @property
    @pulumi.getter(name="authorizationControlFindingsCount")
    def authorization_control_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Authorization Control category.
        """
        return pulumi.get(self, "authorization_control_findings_count")

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

    @property
    @pulumi.getter(name="dataEncryptionFindingsCount")
    def data_encryption_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Data Encryption category.
        """
        return pulumi.get(self, "data_encryption_findings_count")

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

    @property
    @pulumi.getter(name="dbConfigurationFindingsCount")
    def db_configuration_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Database Configuration category.
        """
        return pulumi.get(self, "db_configuration_findings_count")

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

    @property
    @pulumi.getter(name="fineGrainedAccessControlFindingsCount")
    def fine_grained_access_control_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Fine-Grained Access Control category.
        """
        return pulumi.get(self, "fine_grained_access_control_findings_count")

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

    @property
    @pulumi.getter(name="privilegesAndRolesFindingsCount")
    def privileges_and_roles_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Privileges and Roles category.
        """
        return pulumi.get(self, "privileges_and_roles_findings_count")

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

    @property
    @pulumi.getter(name="targetsCount")
    def targets_count(self) -> Optional[pulumi.Input[int]]:
        """
        The total number of targets in this security assessment.
        """
        return pulumi.get(self, "targets_count")

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

    @property
    @pulumi.getter(name="userAccountsFindingsCount")
    def user_accounts_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the User Accounts category.
        """
        return pulumi.get(self, "user_accounts_findings_count")

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


@pulumi.input_type
class SecurityAssessmentStatisticPassArgs:
    def __init__(__self__, *,
                 auditing_findings_count: Optional[pulumi.Input[int]] = None,
                 authorization_control_findings_count: Optional[pulumi.Input[int]] = None,
                 data_encryption_findings_count: Optional[pulumi.Input[int]] = None,
                 db_configuration_findings_count: Optional[pulumi.Input[int]] = None,
                 fine_grained_access_control_findings_count: Optional[pulumi.Input[int]] = None,
                 privileges_and_roles_findings_count: Optional[pulumi.Input[int]] = None,
                 targets_count: Optional[pulumi.Input[int]] = None,
                 user_accounts_findings_count: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] auditing_findings_count: The number of findings in the Auditing category.
        :param pulumi.Input[int] authorization_control_findings_count: The number of findings in the Authorization Control category.
        :param pulumi.Input[int] data_encryption_findings_count: The number of findings in the Data Encryption category.
        :param pulumi.Input[int] db_configuration_findings_count: The number of findings in the Database Configuration category.
        :param pulumi.Input[int] fine_grained_access_control_findings_count: The number of findings in the Fine-Grained Access Control category.
        :param pulumi.Input[int] privileges_and_roles_findings_count: The number of findings in the Privileges and Roles category.
        :param pulumi.Input[int] targets_count: The total number of targets in this security assessment.
        :param pulumi.Input[int] user_accounts_findings_count: The number of findings in the User Accounts category.
        """
        if auditing_findings_count is not None:
            pulumi.set(__self__, "auditing_findings_count", auditing_findings_count)
        if authorization_control_findings_count is not None:
            pulumi.set(__self__, "authorization_control_findings_count", authorization_control_findings_count)
        if data_encryption_findings_count is not None:
            pulumi.set(__self__, "data_encryption_findings_count", data_encryption_findings_count)
        if db_configuration_findings_count is not None:
            pulumi.set(__self__, "db_configuration_findings_count", db_configuration_findings_count)
        if fine_grained_access_control_findings_count is not None:
            pulumi.set(__self__, "fine_grained_access_control_findings_count", fine_grained_access_control_findings_count)
        if privileges_and_roles_findings_count is not None:
            pulumi.set(__self__, "privileges_and_roles_findings_count", privileges_and_roles_findings_count)
        if targets_count is not None:
            pulumi.set(__self__, "targets_count", targets_count)
        if user_accounts_findings_count is not None:
            pulumi.set(__self__, "user_accounts_findings_count", user_accounts_findings_count)

    @property
    @pulumi.getter(name="auditingFindingsCount")
    def auditing_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Auditing category.
        """
        return pulumi.get(self, "auditing_findings_count")

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

    @property
    @pulumi.getter(name="authorizationControlFindingsCount")
    def authorization_control_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Authorization Control category.
        """
        return pulumi.get(self, "authorization_control_findings_count")

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

    @property
    @pulumi.getter(name="dataEncryptionFindingsCount")
    def data_encryption_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Data Encryption category.
        """
        return pulumi.get(self, "data_encryption_findings_count")

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

    @property
    @pulumi.getter(name="dbConfigurationFindingsCount")
    def db_configuration_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Database Configuration category.
        """
        return pulumi.get(self, "db_configuration_findings_count")

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

    @property
    @pulumi.getter(name="fineGrainedAccessControlFindingsCount")
    def fine_grained_access_control_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Fine-Grained Access Control category.
        """
        return pulumi.get(self, "fine_grained_access_control_findings_count")

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

    @property
    @pulumi.getter(name="privilegesAndRolesFindingsCount")
    def privileges_and_roles_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the Privileges and Roles category.
        """
        return pulumi.get(self, "privileges_and_roles_findings_count")

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

    @property
    @pulumi.getter(name="targetsCount")
    def targets_count(self) -> Optional[pulumi.Input[int]]:
        """
        The total number of targets in this security assessment.
        """
        return pulumi.get(self, "targets_count")

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

    @property
    @pulumi.getter(name="userAccountsFindingsCount")
    def user_accounts_findings_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of findings in the User Accounts category.
        """
        return pulumi.get(self, "user_accounts_findings_count")

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


@pulumi.input_type
class TargetDatabaseConnectionOptionArgs:
    def __init__(__self__, *,
                 connection_type: pulumi.Input[str],
                 datasafe_private_endpoint_id: Optional[pulumi.Input[str]] = None,
                 on_prem_connector_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] connection_type: (Updatable) The connection type used to connect to the database. Allowed values:
               * PRIVATE_ENDPOINT - Represents connection through private endpoint in Data Safe.
               * ONPREM_CONNECTOR - Represents connection through on-premises connector in Data Safe.
        :param pulumi.Input[str] datasafe_private_endpoint_id: (Updatable) The OCID of the Data Safe private endpoint.
        :param pulumi.Input[str] on_prem_connector_id: (Updatable) The OCID of the on-premises connector.
        """
        pulumi.set(__self__, "connection_type", connection_type)
        if datasafe_private_endpoint_id is not None:
            pulumi.set(__self__, "datasafe_private_endpoint_id", datasafe_private_endpoint_id)
        if on_prem_connector_id is not None:
            pulumi.set(__self__, "on_prem_connector_id", on_prem_connector_id)

    @property
    @pulumi.getter(name="connectionType")
    def connection_type(self) -> pulumi.Input[str]:
        """
        (Updatable) The connection type used to connect to the database. Allowed values:
        * PRIVATE_ENDPOINT - Represents connection through private endpoint in Data Safe.
        * ONPREM_CONNECTOR - Represents connection through on-premises connector in Data Safe.
        """
        return pulumi.get(self, "connection_type")

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

    @property
    @pulumi.getter(name="datasafePrivateEndpointId")
    def datasafe_private_endpoint_id(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The OCID of the Data Safe private endpoint.
        """
        return pulumi.get(self, "datasafe_private_endpoint_id")

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

    @property
    @pulumi.getter(name="onPremConnectorId")
    def on_prem_connector_id(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The OCID of the on-premises connector.
        """
        return pulumi.get(self, "on_prem_connector_id")

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


@pulumi.input_type
class TargetDatabaseCredentialsArgs:
    def __init__(__self__, *,
                 password: pulumi.Input[str],
                 user_name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] password: (Updatable) The password of the database user.
        :param pulumi.Input[str] user_name: (Updatable) The database user name.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "user_name", user_name)

    @property
    @pulumi.getter
    def password(self) -> pulumi.Input[str]:
        """
        (Updatable) The password of the database user.
        """
        return pulumi.get(self, "password")

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

    @property
    @pulumi.getter(name="userName")
    def user_name(self) -> pulumi.Input[str]:
        """
        (Updatable) The database user name.
        """
        return pulumi.get(self, "user_name")

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


@pulumi.input_type
class TargetDatabaseDatabaseDetailsArgs:
    def __init__(__self__, *,
                 database_type: pulumi.Input[str],
                 infrastructure_type: pulumi.Input[str],
                 autonomous_database_id: Optional[pulumi.Input[str]] = None,
                 db_system_id: Optional[pulumi.Input[str]] = None,
                 instance_id: Optional[pulumi.Input[str]] = None,
                 ip_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 listener_port: Optional[pulumi.Input[int]] = None,
                 service_name: Optional[pulumi.Input[str]] = None,
                 vm_cluster_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] database_type: (Updatable) The database type.
        :param pulumi.Input[str] infrastructure_type: (Updatable) The infrastructure type the database is running on.
        :param pulumi.Input[str] autonomous_database_id: (Updatable) The OCID of the Autonomous Database registered as a target database in Data Safe.
        :param pulumi.Input[str] db_system_id: (Updatable) The OCID of the cloud database registered as a target database in Data Safe.
        :param pulumi.Input[str] instance_id: (Updatable) The OCID of the compute instance on which the database is running.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_addresses: (Updatable) The list of database host IP Addresses. Fully qualified domain names can be used if connectionType is 'ONPREM_CONNECTOR'.
        :param pulumi.Input[int] listener_port: (Updatable) The port number of the database listener.
        :param pulumi.Input[str] service_name: (Updatable) The service name of the database registered as target database.
        :param pulumi.Input[str] vm_cluster_id: (Updatable) The OCID of the VM cluster in which the database is running.
        """
        pulumi.set(__self__, "database_type", database_type)
        pulumi.set(__self__, "infrastructure_type", infrastructure_type)
        if autonomous_database_id is not None:
            pulumi.set(__self__, "autonomous_database_id", autonomous_database_id)
        if db_system_id is not None:
            pulumi.set(__self__, "db_system_id", db_system_id)
        if instance_id is not None:
            pulumi.set(__self__, "instance_id", instance_id)
        if ip_addresses is not None:
            pulumi.set(__self__, "ip_addresses", ip_addresses)
        if listener_port is not None:
            pulumi.set(__self__, "listener_port", listener_port)
        if service_name is not None:
            pulumi.set(__self__, "service_name", service_name)
        if vm_cluster_id is not None:
            pulumi.set(__self__, "vm_cluster_id", vm_cluster_id)

    @property
    @pulumi.getter(name="databaseType")
    def database_type(self) -> pulumi.Input[str]:
        """
        (Updatable) The database type.
        """
        return pulumi.get(self, "database_type")

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

    @property
    @pulumi.getter(name="infrastructureType")
    def infrastructure_type(self) -> pulumi.Input[str]:
        """
        (Updatable) The infrastructure type the database is running on.
        """
        return pulumi.get(self, "infrastructure_type")

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

    @property
    @pulumi.getter(name="autonomousDatabaseId")
    def autonomous_database_id(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The OCID of the Autonomous Database registered as a target database in Data Safe.
        """
        return pulumi.get(self, "autonomous_database_id")

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

    @property
    @pulumi.getter(name="dbSystemId")
    def db_system_id(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The OCID of the cloud database registered as a target database in Data Safe.
        """
        return pulumi.get(self, "db_system_id")

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

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The OCID of the compute instance on which the database is running.
        """
        return pulumi.get(self, "instance_id")

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

    @property
    @pulumi.getter(name="ipAddresses")
    def ip_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        (Updatable) The list of database host IP Addresses. Fully qualified domain names can be used if connectionType is 'ONPREM_CONNECTOR'.
        """
        return pulumi.get(self, "ip_addresses")

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

    @property
    @pulumi.getter(name="listenerPort")
    def listener_port(self) -> Optional[pulumi.Input[int]]:
        """
        (Updatable) The port number of the database listener.
        """
        return pulumi.get(self, "listener_port")

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

    @property
    @pulumi.getter(name="serviceName")
    def service_name(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The service name of the database registered as target database.
        """
        return pulumi.get(self, "service_name")

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

    @property
    @pulumi.getter(name="vmClusterId")
    def vm_cluster_id(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The OCID of the VM cluster in which the database is running.
        """
        return pulumi.get(self, "vm_cluster_id")

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


@pulumi.input_type
class TargetDatabaseTlsConfigArgs:
    def __init__(__self__, *,
                 status: pulumi.Input[str],
                 certificate_store_type: Optional[pulumi.Input[str]] = None,
                 key_store_content: Optional[pulumi.Input[str]] = None,
                 store_password: Optional[pulumi.Input[str]] = None,
                 trust_store_content: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] status: (Updatable) Status to represent whether the database connection is TLS enabled or not.
        :param pulumi.Input[str] certificate_store_type: (Updatable) The format of the certificate store.
        :param pulumi.Input[str] key_store_content: (Updatable) Base64 encoded string of key store file content.
        :param pulumi.Input[str] store_password: (Updatable) The password to read the trust store and key store files, if they are password protected.
        :param pulumi.Input[str] trust_store_content: (Updatable) Base64 encoded string of trust store file content.
               
               
               ** IMPORTANT **
               Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
        """
        pulumi.set(__self__, "status", status)
        if certificate_store_type is not None:
            pulumi.set(__self__, "certificate_store_type", certificate_store_type)
        if key_store_content is not None:
            pulumi.set(__self__, "key_store_content", key_store_content)
        if store_password is not None:
            pulumi.set(__self__, "store_password", store_password)
        if trust_store_content is not None:
            pulumi.set(__self__, "trust_store_content", trust_store_content)

    @property
    @pulumi.getter
    def status(self) -> pulumi.Input[str]:
        """
        (Updatable) Status to represent whether the database connection is TLS enabled or not.
        """
        return pulumi.get(self, "status")

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

    @property
    @pulumi.getter(name="certificateStoreType")
    def certificate_store_type(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The format of the certificate store.
        """
        return pulumi.get(self, "certificate_store_type")

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

    @property
    @pulumi.getter(name="keyStoreContent")
    def key_store_content(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) Base64 encoded string of key store file content.
        """
        return pulumi.get(self, "key_store_content")

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

    @property
    @pulumi.getter(name="storePassword")
    def store_password(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) The password to read the trust store and key store files, if they are password protected.
        """
        return pulumi.get(self, "store_password")

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

    @property
    @pulumi.getter(name="trustStoreContent")
    def trust_store_content(self) -> Optional[pulumi.Input[str]]:
        """
        (Updatable) Base64 encoded string of trust store file content.


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

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


@pulumi.input_type
class UserAssessmentIgnoredTargetArgs:
    def __init__(__self__, *,
                 lifecycle_state: Optional[pulumi.Input[str]] = None,
                 target_id: Optional[pulumi.Input[str]] = None,
                 user_assessment_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] target_id: The OCID of the target database on which the user assessment is to be run.
               
               
               ** 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
        """
        if lifecycle_state is not None:
            pulumi.set(__self__, "lifecycle_state", lifecycle_state)
        if target_id is not None:
            pulumi.set(__self__, "target_id", target_id)
        if user_assessment_id is not None:
            pulumi.set(__self__, "user_assessment_id", user_assessment_id)

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

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

    @property
    @pulumi.getter(name="targetId")
    def target_id(self) -> Optional[pulumi.Input[str]]:
        """
        The OCID of the target database on which the user assessment is to be run.


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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


@pulumi.input_type
class GetReportDefinitionsFilterArgs:
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str],
                 regex: Optional[bool] = None):
        """
        :param str name: Name of the report summary.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)
        if regex is not None:
            pulumi.set(__self__, "regex", regex)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the report summary.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


