pulumi-oci 2.12.0__py3-none-any.whl → 2.12.0a1726829632__py3-none-any.whl

pulumi_oci/datasafe/_inputs.py

@@ -4,270 +4,121 @@
 
 import copy
 import warnings
-import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
-if sys.version_info >= (3, 11):
-    from typing import NotRequired, TypedDict, TypeAlias
-else:
-    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
 
 __all__ = [
     'AlertPolicyAlertPolicyRuleDetailArgs',
-    'AlertPolicyAlertPolicyRuleDetailArgsDict',
     'AuditPolicyAuditConditionArgs',
-    'AuditPolicyAuditConditionArgsDict',
     'AuditPolicyAuditConditionEnableConditionArgs',
-    'AuditPolicyAuditConditionEnableConditionArgsDict',
     'AuditPolicyAuditSpecificationArgs',
-    'AuditPolicyAuditSpecificationArgsDict',
     'AuditPolicyManagementAuditConditionArgs',
-    'AuditPolicyManagementAuditConditionArgsDict',
     'AuditPolicyManagementAuditConditionEnableConditionArgs',
-    'AuditPolicyManagementAuditConditionEnableConditionArgsDict',
     'AuditPolicyManagementAuditSpecificationArgs',
-    'AuditPolicyManagementAuditSpecificationArgsDict',
     'AuditProfileAuditTrailArgs',
-    'AuditProfileAuditTrailArgsDict',
     'CalculateAuditVolumeAvailableAvailableAuditVolumeArgs',
-    'CalculateAuditVolumeAvailableAvailableAuditVolumeArgsDict',
     'CalculateAuditVolumeCollectedCollectedAuditVolumeArgs',
-    'CalculateAuditVolumeCollectedCollectedAuditVolumeArgsDict',
     'DataSafeConfigurationGlobalSettingArgs',
-    'DataSafeConfigurationGlobalSettingArgsDict',
     'DatabaseSecurityConfigManagementSqlFirewallConfigArgs',
-    'DatabaseSecurityConfigManagementSqlFirewallConfigArgsDict',
     'DatabaseSecurityConfigSqlFirewallConfigArgs',
-    'DatabaseSecurityConfigSqlFirewallConfigArgsDict',
     'DiscoveryJobsResultModifiedAttributeArgs',
-    'DiscoveryJobsResultModifiedAttributeArgsDict',
     'DiscoveryModTablesForDiscoveryArgs',
-    'DiscoveryModTablesForDiscoveryArgsDict',
     'LibraryMasingFormatFormatEntryArgs',
-    'LibraryMasingFormatFormatEntryArgsDict',
     'MaskingPoliciesMaskingColumnMaskingFormatArgs',
-    'MaskingPoliciesMaskingColumnMaskingFormatArgsDict',
     'MaskingPoliciesMaskingColumnMaskingFormatFormatEntryArgs',
-    'MaskingPoliciesMaskingColumnMaskingFormatFormatEntryArgsDict',
     'MaskingPolicyColumnSourceArgs',
-    'MaskingPolicyColumnSourceArgsDict',
     'ReportDefinitionColumnFilterArgs',
-    'ReportDefinitionColumnFilterArgsDict',
     'ReportDefinitionColumnInfoArgs',
-    'ReportDefinitionColumnInfoArgsDict',
     'ReportDefinitionColumnSortingArgs',
-    'ReportDefinitionColumnSortingArgsDict',
     'ReportDefinitionSummaryArgs',
-    'ReportDefinitionSummaryArgsDict',
     'SecurityAssessmentStatisticArgs',
-    'SecurityAssessmentStatisticArgsDict',
     'SecurityAssessmentStatisticAdvisoryArgs',
-    'SecurityAssessmentStatisticAdvisoryArgsDict',
     'SecurityAssessmentStatisticDeferredArgs',
-    'SecurityAssessmentStatisticDeferredArgsDict',
     'SecurityAssessmentStatisticEvaluateArgs',
-    'SecurityAssessmentStatisticEvaluateArgsDict',
     'SecurityAssessmentStatisticHighRiskArgs',
-    'SecurityAssessmentStatisticHighRiskArgsDict',
     'SecurityAssessmentStatisticLowRiskArgs',
-    'SecurityAssessmentStatisticLowRiskArgsDict',
     'SecurityAssessmentStatisticMediumRiskArgs',
-    'SecurityAssessmentStatisticMediumRiskArgsDict',
     'SecurityAssessmentStatisticPassArgs',
-    'SecurityAssessmentStatisticPassArgsDict',
     'SensitiveDataModelTablesForDiscoveryArgs',
-    'SensitiveDataModelTablesForDiscoveryArgsDict',
     'TargetDatabaseConnectionOptionArgs',
-    'TargetDatabaseConnectionOptionArgsDict',
     'TargetDatabaseCredentialsArgs',
-    'TargetDatabaseCredentialsArgsDict',
     'TargetDatabaseDatabaseDetailsArgs',
-    'TargetDatabaseDatabaseDetailsArgsDict',
     'TargetDatabasePeerTargetDatabaseArgs',
-    'TargetDatabasePeerTargetDatabaseArgsDict',
     'TargetDatabasePeerTargetDatabaseDatabaseDetailArgs',
-    'TargetDatabasePeerTargetDatabaseDatabaseDetailArgsDict',
     'TargetDatabasePeerTargetDatabaseDatabaseDetailsArgs',
-    'TargetDatabasePeerTargetDatabaseDatabaseDetailsArgsDict',
     'TargetDatabasePeerTargetDatabaseDetailArgs',
-    'TargetDatabasePeerTargetDatabaseDetailArgsDict',
     'TargetDatabasePeerTargetDatabaseDetailDatabaseDetailsArgs',
-    'TargetDatabasePeerTargetDatabaseDetailDatabaseDetailsArgsDict',
     'TargetDatabasePeerTargetDatabaseDetailTlsConfigArgs',
-    'TargetDatabasePeerTargetDatabaseDetailTlsConfigArgsDict',
     'TargetDatabasePeerTargetDatabaseTlsConfigArgs',
-    'TargetDatabasePeerTargetDatabaseTlsConfigArgsDict',
     'TargetDatabaseTlsConfigArgs',
-    'TargetDatabaseTlsConfigArgsDict',
     'UserAssessmentIgnoredTargetArgs',
-    'UserAssessmentIgnoredTargetArgsDict',
     'GetAlertPoliciesFilterArgs',
-    'GetAlertPoliciesFilterArgsDict',
     'GetAlertPolicyRulesFilterArgs',
-    'GetAlertPolicyRulesFilterArgsDict',
     'GetAlertsFilterArgs',
-    'GetAlertsFilterArgsDict',
     'GetAuditArchiveRetrievalsFilterArgs',
-    'GetAuditArchiveRetrievalsFilterArgsDict',
     'GetAuditEventsFilterArgs',
-    'GetAuditEventsFilterArgsDict',
     'GetAuditPoliciesFilterArgs',
-    'GetAuditPoliciesFilterArgsDict',
     'GetAuditProfileAvailableAuditVolumesFilterArgs',
-    'GetAuditProfileAvailableAuditVolumesFilterArgsDict',
     'GetAuditProfileCollectedAuditVolumesFilterArgs',
-    'GetAuditProfileCollectedAuditVolumesFilterArgsDict',
     'GetAuditProfilesFilterArgs',
-    'GetAuditProfilesFilterArgsDict',
     'GetAuditTrailsFilterArgs',
-    'GetAuditTrailsFilterArgsDict',
     'GetDataSafePrivateEndpointsFilterArgs',
-    'GetDataSafePrivateEndpointsFilterArgsDict',
     'GetDiscoveryAnalyticsFilterArgs',
-    'GetDiscoveryAnalyticsFilterArgsDict',
     'GetDiscoveryJobsResultsFilterArgs',
-    'GetDiscoveryJobsResultsFilterArgsDict',
     'GetLibraryMaskingFormatsFilterArgs',
-    'GetLibraryMaskingFormatsFilterArgsDict',
     'GetListUserGrantsFilterArgs',
-    'GetListUserGrantsFilterArgsDict',
     'GetMaskingAnalyticsFilterArgs',
-    'GetMaskingAnalyticsFilterArgsDict',
     'GetMaskingPoliciesFilterArgs',
-    'GetMaskingPoliciesFilterArgsDict',
     'GetMaskingPoliciesMaskingColumnsFilterArgs',
-    'GetMaskingPoliciesMaskingColumnsFilterArgsDict',
     'GetMaskingPolicyHealthReportLogsFilterArgs',
-    'GetMaskingPolicyHealthReportLogsFilterArgsDict',
     'GetMaskingPolicyHealthReportsFilterArgs',
-    'GetMaskingPolicyHealthReportsFilterArgsDict',
     'GetMaskingPolicyMaskingObjectsFilterArgs',
-    'GetMaskingPolicyMaskingObjectsFilterArgsDict',
     'GetMaskingPolicyMaskingSchemasFilterArgs',
-    'GetMaskingPolicyMaskingSchemasFilterArgsDict',
     'GetMaskingReportMaskedColumnsFilterArgs',
-    'GetMaskingReportMaskedColumnsFilterArgsDict',
     'GetMaskingReportsFilterArgs',
-    'GetMaskingReportsFilterArgsDict',
     'GetOnpremConnectorsFilterArgs',
-    'GetOnpremConnectorsFilterArgsDict',
     'GetReportDefinitionsFilterArgs',
-    'GetReportDefinitionsFilterArgsDict',
     'GetReportsFilterArgs',
-    'GetReportsFilterArgsDict',
     'GetSdmMaskingPolicyDifferenceDifferenceColumnsFilterArgs',
-    'GetSdmMaskingPolicyDifferenceDifferenceColumnsFilterArgsDict',
     'GetSdmMaskingPolicyDifferencesFilterArgs',
-    'GetSdmMaskingPolicyDifferencesFilterArgsDict',
     'GetSecurityAssessmentFindingAnalyticsFilterArgs',
-    'GetSecurityAssessmentFindingAnalyticsFilterArgsDict',
     'GetSecurityAssessmentFindingFilterArgs',
-    'GetSecurityAssessmentFindingFilterArgsDict',
     'GetSecurityAssessmentFindingsChangeAuditLogsFilterArgs',
-    'GetSecurityAssessmentFindingsChangeAuditLogsFilterArgsDict',
     'GetSecurityAssessmentFindingsFilterArgs',
-    'GetSecurityAssessmentFindingsFilterArgsDict',
     'GetSecurityAssessmentSecurityFeatureAnalyticsFilterArgs',
-    'GetSecurityAssessmentSecurityFeatureAnalyticsFilterArgsDict',
     'GetSecurityAssessmentSecurityFeaturesFilterArgs',
-    'GetSecurityAssessmentSecurityFeaturesFilterArgsDict',
     'GetSecurityAssessmentsFilterArgs',
-    'GetSecurityAssessmentsFilterArgsDict',
     'GetSecurityPoliciesFilterArgs',
-    'GetSecurityPoliciesFilterArgsDict',
     'GetSecurityPolicyDeploymentSecurityPolicyEntryStatesFilterArgs',
-    'GetSecurityPolicyDeploymentSecurityPolicyEntryStatesFilterArgsDict',
     'GetSecurityPolicyDeploymentsFilterArgs',
-    'GetSecurityPolicyDeploymentsFilterArgsDict',
     'GetSecurityPolicyReportDatabaseTableAccessEntriesFilterArgs',
-    'GetSecurityPolicyReportDatabaseTableAccessEntriesFilterArgsDict',
     'GetSecurityPolicyReportDatabaseViewAccessEntriesFilterArgs',
-    'GetSecurityPolicyReportDatabaseViewAccessEntriesFilterArgsDict',
     'GetSecurityPolicyReportRoleGrantPathsFilterArgs',
-    'GetSecurityPolicyReportRoleGrantPathsFilterArgsDict',
     'GetSecurityPolicyReportsFilterArgs',
-    'GetSecurityPolicyReportsFilterArgsDict',
     'GetSensitiveDataModelSensitiveObjectsFilterArgs',
-    'GetSensitiveDataModelSensitiveObjectsFilterArgsDict',
     'GetSensitiveDataModelSensitiveSchemasFilterArgs',
-    'GetSensitiveDataModelSensitiveSchemasFilterArgsDict',
     'GetSensitiveDataModelSensitiveTypesFilterArgs',
-    'GetSensitiveDataModelSensitiveTypesFilterArgsDict',
     'GetSensitiveDataModelsFilterArgs',
-    'GetSensitiveDataModelsFilterArgsDict',
     'GetSensitiveDataModelsSensitiveColumnsFilterArgs',
-    'GetSensitiveDataModelsSensitiveColumnsFilterArgsDict',
     'GetSensitiveTypesFilterArgs',
-    'GetSensitiveTypesFilterArgsDict',
-    'GetSqlCollectionAnalyticsFilterArgs',
-    'GetSqlCollectionAnalyticsFilterArgsDict',
-    'GetSqlCollectionLogInsightsFilterArgs',
-    'GetSqlCollectionLogInsightsFilterArgsDict',
-    'GetSqlCollectionsFilterArgs',
-    'GetSqlCollectionsFilterArgsDict',
-    'GetSqlFirewallAllowedSqlAnalyticsFilterArgs',
-    'GetSqlFirewallAllowedSqlAnalyticsFilterArgsDict',
-    'GetSqlFirewallAllowedSqlsFilterArgs',
-    'GetSqlFirewallAllowedSqlsFilterArgsDict',
-    'GetSqlFirewallPoliciesFilterArgs',
-    'GetSqlFirewallPoliciesFilterArgsDict',
-    'GetSqlFirewallPolicyAnalyticsFilterArgs',
-    'GetSqlFirewallPolicyAnalyticsFilterArgsDict',
-    'GetSqlFirewallViolationAnalyticsFilterArgs',
-    'GetSqlFirewallViolationAnalyticsFilterArgsDict',
-    'GetSqlFirewallViolationsFilterArgs',
-    'GetSqlFirewallViolationsFilterArgsDict',
     'GetTargetAlertPolicyAssociationsFilterArgs',
-    'GetTargetAlertPolicyAssociationsFilterArgsDict',
     'GetTargetDatabasePeerTargetDatabasesFilterArgs',
-    'GetTargetDatabasePeerTargetDatabasesFilterArgsDict',
     'GetTargetDatabaseRoleFilterArgs',
-    'GetTargetDatabaseRoleFilterArgsDict',
     'GetTargetDatabaseRolesFilterArgs',
-    'GetTargetDatabaseRolesFilterArgsDict',
     'GetTargetDatabasesColumnsFilterArgs',
-    'GetTargetDatabasesColumnsFilterArgsDict',
     'GetTargetDatabasesFilterArgs',
-    'GetTargetDatabasesFilterArgsDict',
     'GetTargetDatabasesSchemasFilterArgs',
-    'GetTargetDatabasesSchemasFilterArgsDict',
     'GetTargetDatabasesTablesFilterArgs',
-    'GetTargetDatabasesTablesFilterArgsDict',
     'GetUserAssessmentProfileAnalyticsFilterArgs',
-    'GetUserAssessmentProfileAnalyticsFilterArgsDict',
     'GetUserAssessmentProfilesFilterArgs',
-    'GetUserAssessmentProfilesFilterArgsDict',
     'GetUserAssessmentUserAccessAnalyticsFilterArgs',
-    'GetUserAssessmentUserAccessAnalyticsFilterArgsDict',
     'GetUserAssessmentUserAnalyticsFilterArgs',
-    'GetUserAssessmentUserAnalyticsFilterArgsDict',
     'GetUserAssessmentUsersFilterArgs',
-    'GetUserAssessmentUsersFilterArgsDict',
     'GetUserAssessmentsFilterArgs',
-    'GetUserAssessmentsFilterArgsDict',
 ]
 
-MYPY = False
-
-if not MYPY:
-    class AlertPolicyAlertPolicyRuleDetailArgsDict(TypedDict):
-        expression: pulumi.Input[str]
-        """
-        The conditional expression of the alert policy rule which evaluates to boolean value.
-        """
-        description: NotRequired[pulumi.Input[str]]
-        """
-        Describes the alert policy rule.
-        """
-        display_name: NotRequired[pulumi.Input[str]]
-        """
-        The display name of the alert policy rule.
-        """
-elif False:
-    AlertPolicyAlertPolicyRuleDetailArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class AlertPolicyAlertPolicyRuleDetailArgs:
     def __init__(__self__, *,
@@ -322,27 +173,6 @@ class AlertPolicyAlertPolicyRuleDetailArgs:
         pulumi.set(self, "display_name", value)
 
 
-if not MYPY:
-    class AuditPolicyAuditConditionArgsDict(TypedDict):
-        audit_policy_name: NotRequired[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.
-        """
-        enable_conditions: NotRequired[pulumi.Input[Sequence[pulumi.Input['AuditPolicyAuditConditionEnableConditionArgsDict']]]]
-        """
-        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..
-        """
-        is_data_safe_service_account_audited: NotRequired[pulumi.Input[bool]]
-        """
-        Indicates whether the Data Safe user activity on the target database will be audited by the policy.
-        """
-        is_priv_users_managed_by_data_safe: NotRequired[pulumi.Input[bool]]
-        """
-        Indicates whether the privileged user list is managed by Data Safe.
-        """
-elif False:
-    AuditPolicyAuditConditionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class AuditPolicyAuditConditionArgs:
     def __init__(__self__, *,
@@ -414,27 +244,6 @@ class AuditPolicyAuditConditionArgs:
         pulumi.set(self, "is_priv_users_managed_by_data_safe", value)
 
 
-if not MYPY:
-    class AuditPolicyAuditConditionEnableConditionArgsDict(TypedDict):
-        entity_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        List of users or roles that the policy must be enabled for.
-        """
-        entity_selection: NotRequired[pulumi.Input[str]]
-        """
-        The entity include or exclude selection.
-        """
-        entity_type: NotRequired[pulumi.Input[str]]
-        """
-        The entity type that the policy must be enabled for.
-        """
-        operation_status: NotRequired[pulumi.Input[str]]
-        """
-        The operation status that the policy must be enabled for.
-        """
-elif False:
-    AuditPolicyAuditConditionEnableConditionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class AuditPolicyAuditConditionEnableConditionArgs:
     def __init__(__self__, *,
@@ -506,55 +315,6 @@ class AuditPolicyAuditConditionEnableConditionArgs:
         pulumi.set(self, "operation_status", value)
 
 
-if not MYPY:
-    class AuditPolicyAuditSpecificationArgsDict(TypedDict):
-        audit_policy_category: NotRequired[pulumi.Input[str]]
-        """
-        The category to which the audit policy belongs.
-        """
-        audit_policy_name: NotRequired[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.
-        """
-        database_policy_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Indicates the names of corresponding database policy ( or policies) in the target database.
-        """
-        enable_status: NotRequired[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.
-        """
-        enabled_entities: NotRequired[pulumi.Input[str]]
-        """
-        Indicates on whom the audit policy is enabled.
-        """
-        is_created: NotRequired[pulumi.Input[bool]]
-        """
-        Indicates whether the policy is already created on the target database.
-        """
-        is_enabled_for_all_users: NotRequired[pulumi.Input[bool]]
-        """
-        Indicates whether the policy by default is enabled for all users with no flexibility to alter the enablement conditions.
-        """
-        is_seeded_in_data_safe: NotRequired[pulumi.Input[bool]]
-        """
-        Indicates whether the audit policy is one of the seeded policies provided by Oracle Data Safe.
-        """
-        is_seeded_in_target: NotRequired[pulumi.Input[bool]]
-        """
-        Indicates whether the audit policy is one of the predefined policies provided by Oracle Database.
-        """
-        is_view_only: NotRequired[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.
-        """
-        partially_enabled_msg: NotRequired[pulumi.Input[str]]
-        """
-        Provides information about the policy that has been only partially enabled.
-        """
-elif False:
-    AuditPolicyAuditSpecificationArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class AuditPolicyAuditSpecificationArgs:
     def __init__(__self__, *,
@@ -738,35 +498,6 @@ class AuditPolicyAuditSpecificationArgs:
         pulumi.set(self, "partially_enabled_msg", value)
 
 
-if not MYPY:
-    class AuditPolicyManagementAuditConditionArgsDict(TypedDict):
-        audit_policy_name: NotRequired[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.
-        """
-        enable_conditions: NotRequired[pulumi.Input[Sequence[pulumi.Input['AuditPolicyManagementAuditConditionEnableConditionArgsDict']]]]
-        """
-        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..
-        """
-        is_data_safe_service_account_audited: NotRequired[pulumi.Input[bool]]
-        """
-        Indicates whether the Data Safe user activity on the target database will be audited by the policy.
-        """
-        is_enabled: NotRequired[pulumi.Input[bool]]
-        """
-        Indicates whether the policy has to be enabled or disabled in the target database. Set this to true if you want the audit policy to be enabled in the target database. If the seeded audit policy is not already created in the database, the provisioning creates and enables them. If this is set to false, the policy will be disabled in the target database.
-        """
-        is_priv_users_managed_by_data_safe: NotRequired[pulumi.Input[bool]]
-        """
-        Indicates whether the privileged user list is managed by Data Safe.
-
-
-        ** IMPORTANT **
-        Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
-        """
-elif False:
-    AuditPolicyManagementAuditConditionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class AuditPolicyManagementAuditConditionArgs:
     def __init__(__self__, *,
@@ -862,27 +593,6 @@ class AuditPolicyManagementAuditConditionArgs:
         pulumi.set(self, "is_priv_users_managed_by_data_safe", value)
 
 
-if not MYPY:
-    class AuditPolicyManagementAuditConditionEnableConditionArgsDict(TypedDict):
-        entity_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        List of users or roles that the policy must be enabled for.
-        """
-        entity_selection: NotRequired[pulumi.Input[str]]
-        """
-        The entity include or exclude selection.
-        """
-        entity_type: NotRequired[pulumi.Input[str]]
-        """
-        The entity type that the policy must be enabled for.
-        """
-        operation_status: NotRequired[pulumi.Input[str]]
-        """
-        The operation status that the policy must be enabled for.
-        """
-elif False:
-    AuditPolicyManagementAuditConditionEnableConditionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class AuditPolicyManagementAuditConditionEnableConditionArgs:
     def __init__(__self__, *,
@@ -954,55 +664,6 @@ class AuditPolicyManagementAuditConditionEnableConditionArgs:
         pulumi.set(self, "operation_status", value)
 
 
-if not MYPY:
-    class AuditPolicyManagementAuditSpecificationArgsDict(TypedDict):
-        audit_policy_category: NotRequired[pulumi.Input[str]]
-        """
-        The category to which the audit policy belongs.
-        """
-        audit_policy_name: NotRequired[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.
-        """
-        database_policy_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Indicates the names of corresponding database policy ( or policies) in the target database.
-        """
-        enable_status: NotRequired[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.
-        """
-        enabled_entities: NotRequired[pulumi.Input[str]]
-        """
-        Indicates on whom the audit policy is enabled.
-        """
-        is_created: NotRequired[pulumi.Input[bool]]
-        """
-        Indicates whether the policy is already created on the target database.
-        """
-        is_enabled_for_all_users: NotRequired[pulumi.Input[bool]]
-        """
-        Indicates whether the policy by default is enabled for all users with no flexibility to alter the enablement conditions.
-        """
-        is_seeded_in_data_safe: NotRequired[pulumi.Input[bool]]
-        """
-        Indicates whether the audit policy is one of the seeded policies provided by Oracle Data Safe.
-        """
-        is_seeded_in_target: NotRequired[pulumi.Input[bool]]
-        """
-        Indicates whether the audit policy is one of the predefined policies provided by Oracle Database.
-        """
-        is_view_only: NotRequired[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.
-        """
-        partially_enabled_msg: NotRequired[pulumi.Input[str]]
-        """
-        Provides information about the policy that has been only partially enabled.
-        """
-elif False:
-    AuditPolicyManagementAuditSpecificationArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class AuditPolicyManagementAuditSpecificationArgs:
     def __init__(__self__, *,
@@ -1186,107 +847,6 @@ class AuditPolicyManagementAuditSpecificationArgs:
         pulumi.set(self, "partially_enabled_msg", value)
 
 
-if not MYPY:
-    class AuditProfileAuditTrailArgsDict(TypedDict):
-        audit_collection_start_time: NotRequired[pulumi.Input[str]]
-        """
-        The date from which the audit trail must start collecting data, in the format defined by RFC3339.
-        """
-        audit_profile_id: NotRequired[pulumi.Input[str]]
-        """
-        The OCID of the audit.
-        """
-        compartment_id: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The OCID of the compartment that contains the audit.
-        """
-        defined_tags: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
-        """
-        (Updatable) Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm)  Example: `{"Operations.CostCenter": "42"}`
-        """
-        description: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The description of the audit profile.
-        """
-        display_name: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The display name of the audit profile. The name does not have to be unique, and it's changeable.
-        """
-        freeform_tags: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
-        """
-        (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"}`
-        """
-        id: NotRequired[pulumi.Input[str]]
-        """
-        The OCID of the audit profile.
-        """
-        is_auto_purge_enabled: NotRequired[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.
-        """
-        lifecycle_details: NotRequired[pulumi.Input[str]]
-        """
-        Details about the current state of the audit profile in Data Safe.
-        """
-        peer_target_database_key: NotRequired[pulumi.Input[int]]
-        """
-        The secondary id assigned for the peer database registered with Data Safe.
-        """
-        purge_job_details: NotRequired[pulumi.Input[str]]
-        """
-        The details of the audit trail purge job that ran on the "purgeJobTime".
-        """
-        purge_job_status: NotRequired[pulumi.Input[str]]
-        """
-        The current status of the audit trail purge job.
-        """
-        purge_job_time: NotRequired[pulumi.Input[str]]
-        """
-        The date and time of the last purge job, which deletes audit data in the target database every seven days so that the database's audit trail does not become too large. In the format defined by RFC3339.
-        """
-        state: NotRequired[pulumi.Input[str]]
-        """
-        The current state of the audit profile.
-        """
-        status: NotRequired[pulumi.Input[str]]
-        """
-        The current sub-state of the audit trail.
-        """
-        system_tags: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
-        """
-        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"}`
-        """
-        target_id: NotRequired[pulumi.Input[str]]
-        """
-        The OCID of the Data Safe target for which the audit profile is created.
-        """
-        time_created: NotRequired[pulumi.Input[str]]
-        """
-        The date and time the audit profile was created, in the format defined by RFC3339.
-        """
-        time_last_collected: NotRequired[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.
-        """
-        time_updated: NotRequired[pulumi.Input[str]]
-        """
-        The date and time the audit profile was updated, in the format defined by RFC3339.
-        """
-        trail_location: NotRequired[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.
-        """
-        trail_source: NotRequired[pulumi.Input[str]]
-        """
-        The underlying source of unified audit trail.
-        """
-        work_request_id: NotRequired[pulumi.Input[str]]
-        """
-        The OCID of the workrequest for audit trail which collects audit records.
-        """
-elif False:
-    AuditProfileAuditTrailArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class AuditProfileAuditTrailArgs:
     def __init__(__self__, *,
@@ -1678,18 +1238,6 @@ class AuditProfileAuditTrailArgs:
         pulumi.set(self, "work_request_id", value)
 
 
-if not MYPY:
-    class CalculateAuditVolumeAvailableAvailableAuditVolumeArgsDict(TypedDict):
-        audit_profile_id: NotRequired[pulumi.Input[str]]
-        """
-        The OCID of the audit.
-        """
-        month_in_consideration: NotRequired[pulumi.Input[str]]
-        trail_location: NotRequired[pulumi.Input[str]]
-        volume: NotRequired[pulumi.Input[str]]
-elif False:
-    CalculateAuditVolumeAvailableAvailableAuditVolumeArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class CalculateAuditVolumeAvailableAvailableAuditVolumeArgs:
     def __init__(__self__, *,
@@ -1749,18 +1297,6 @@ class CalculateAuditVolumeAvailableAvailableAuditVolumeArgs:
         pulumi.set(self, "volume", value)
 
 
-if not MYPY:
-    class CalculateAuditVolumeCollectedCollectedAuditVolumeArgsDict(TypedDict):
-        archived_volume: NotRequired[pulumi.Input[str]]
-        audit_profile_id: NotRequired[pulumi.Input[str]]
-        """
-        The OCID of the audit.
-        """
-        month_in_consideration: NotRequired[pulumi.Input[str]]
-        online_volume: NotRequired[pulumi.Input[str]]
-elif False:
-    CalculateAuditVolumeCollectedCollectedAuditVolumeArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class CalculateAuditVolumeCollectedCollectedAuditVolumeArgs:
     def __init__(__self__, *,
@@ -1820,23 +1356,6 @@ class CalculateAuditVolumeCollectedCollectedAuditVolumeArgs:
         pulumi.set(self, "online_volume", value)
 
 
-if not MYPY:
-    class DataSafeConfigurationGlobalSettingArgsDict(TypedDict):
-        is_paid_usage: NotRequired[pulumi.Input[bool]]
-        """
-        The paid usage option chosen by the customer admin.
-        """
-        offline_retention_period: NotRequired[pulumi.Input[int]]
-        """
-        The offline retention period in months.
-        """
-        online_retention_period: NotRequired[pulumi.Input[int]]
-        """
-        The online retention period in months.
-        """
-elif False:
-    DataSafeConfigurationGlobalSettingArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class DataSafeConfigurationGlobalSettingArgs:
     def __init__(__self__, *,
@@ -1892,27 +1411,6 @@ class DataSafeConfigurationGlobalSettingArgs:
         pulumi.set(self, "online_retention_period", value)
 
 
-if not MYPY:
-    class DatabaseSecurityConfigManagementSqlFirewallConfigArgsDict(TypedDict):
-        exclude_job: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) Specifies whether the firewall should include or exclude the database internal job activities.
-        """
-        status: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) Specifies whether the firewall is enabled or disabled on the target database.
-        """
-        time_status_updated: NotRequired[pulumi.Input[str]]
-        """
-        The most recent time when the firewall status is updated, in the format defined by RFC3339.
-        """
-        violation_log_auto_purge: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) Specifies whether Data Safe should automatically purge the violation logs  from the database after collecting the violation logs and persisting on Data Safe.
-        """
-elif False:
-    DatabaseSecurityConfigManagementSqlFirewallConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class DatabaseSecurityConfigManagementSqlFirewallConfigArgs:
     def __init__(__self__, *,
@@ -1984,27 +1482,6 @@ class DatabaseSecurityConfigManagementSqlFirewallConfigArgs:
         pulumi.set(self, "violation_log_auto_purge", value)
 
 
-if not MYPY:
-    class DatabaseSecurityConfigSqlFirewallConfigArgsDict(TypedDict):
-        exclude_job: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) Specifies whether the firewall should include or exclude the database internal job activities.
-        """
-        status: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) Specifies whether the firewall is enabled or disabled on the target database.
-        """
-        time_status_updated: NotRequired[pulumi.Input[str]]
-        """
-        The most recent time when the firewall status is updated, in the format defined by RFC3339.
-        """
-        violation_log_auto_purge: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) Specifies whether Data Safe should automatically purge the violation logs  from the database after collecting the violation logs and persisting on Data Safe.
-        """
-elif False:
-    DatabaseSecurityConfigSqlFirewallConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class DatabaseSecurityConfigSqlFirewallConfigArgs:
     def __init__(__self__, *,
@@ -2076,19 +1553,6 @@ class DatabaseSecurityConfigSqlFirewallConfigArgs:
         pulumi.set(self, "violation_log_auto_purge", value)
 
 
-if not MYPY:
-    class DiscoveryJobsResultModifiedAttributeArgsDict(TypedDict):
-        app_defined_child_column_keys: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Unique keys identifying the columns that are application-level (non-dictionary) children of the sensitive column.
-        """
-        db_defined_child_column_keys: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Unique keys identifying the columns that are database-level (dictionary-defined) children of the sensitive column.
-        """
-elif False:
-    DiscoveryJobsResultModifiedAttributeArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class DiscoveryJobsResultModifiedAttributeArgs:
     def __init__(__self__, *,
@@ -2128,23 +1592,6 @@ class DiscoveryJobsResultModifiedAttributeArgs:
         pulumi.set(self, "db_defined_child_column_keys", value)
 
 
-if not MYPY:
-    class DiscoveryModTablesForDiscoveryArgsDict(TypedDict):
-        schema_name: pulumi.Input[str]
-        """
-        This contains the name of the schema.
-        """
-        table_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        This contains an optional list of the table names.
-
-
-        ** IMPORTANT **
-        Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
-        """
-elif False:
-    DiscoveryModTablesForDiscoveryArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class DiscoveryModTablesForDiscoveryArgs:
     def __init__(__self__, *,
@@ -2191,111 +1638,6 @@ class DiscoveryModTablesForDiscoveryArgs:
         pulumi.set(self, "table_names", value)
 
 
-if not MYPY:
-    class LibraryMasingFormatFormatEntryArgsDict(TypedDict):
-        type: pulumi.Input[str]
-        """
-        (Updatable) The type of the format entry.
-        """
-        column_name: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The name of the substitution column.
-        """
-        description: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The description of the format entry.
-        """
-        end_date: NotRequired[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.
-        """
-        end_length: NotRequired[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.
-        """
-        end_value: NotRequired[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.
-        """
-        fixed_number: NotRequired[pulumi.Input[float]]
-        """
-        (Updatable) The constant number to be used for masking.
-        """
-        fixed_string: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The constant string to be used for masking.
-        """
-        grouping_columns: NotRequired[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.
-        """
-        length: NotRequired[pulumi.Input[int]]
-        """
-        (Updatable) The number of characters that should be there in the substring. It should be an integer and greater than zero.
-        """
-        library_masking_format_id: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The OCID of the library masking format.
-        """
-        pattern: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The pattern that should be used to mask data.
-        """
-        post_processing_function: NotRequired[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.
-        """
-        random_lists: NotRequired[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.
-        """
-        regular_expression: NotRequired[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.
-        """
-        replace_with: NotRequired[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.
-        """
-        schema_name: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The name of the schema that contains the substitution column.
-        """
-        sql_expression: NotRequired[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.
-        """
-        start_date: NotRequired[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.
-        """
-        start_length: NotRequired[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.
-        """
-        start_position: NotRequired[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.
-        """
-        start_value: NotRequired[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.
-        """
-        table_name: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The name of the table that contains the substitution column.
-        """
-        user_defined_function: NotRequired[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.
-        """
-elif False:
-    LibraryMasingFormatFormatEntryArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class LibraryMasingFormatFormatEntryArgs:
     def __init__(__self__, *,
@@ -2694,23 +2036,6 @@ class LibraryMasingFormatFormatEntryArgs:
         pulumi.set(self, "user_defined_function", value)
 
 
-if not MYPY:
-    class MaskingPoliciesMaskingColumnMaskingFormatArgsDict(TypedDict):
-        format_entries: pulumi.Input[Sequence[pulumi.Input['MaskingPoliciesMaskingColumnMaskingFormatFormatEntryArgsDict']]]
-        """
-        (Updatable) An array of format entries. The combined output of all the format entries is  used for masking the column data values.
-        """
-        condition: NotRequired[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.
-        """
-        description: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The description of the masking format.
-        """
-elif False:
-    MaskingPoliciesMaskingColumnMaskingFormatArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class MaskingPoliciesMaskingColumnMaskingFormatArgs:
     def __init__(__self__, *,
@@ -2765,111 +2090,6 @@ class MaskingPoliciesMaskingColumnMaskingFormatArgs:
         pulumi.set(self, "description", value)
 
 
-if not MYPY:
-    class MaskingPoliciesMaskingColumnMaskingFormatFormatEntryArgsDict(TypedDict):
-        type: pulumi.Input[str]
-        """
-        (Updatable) The type of the format entry.
-        """
-        column_name: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The name of the substitution column.
-        """
-        description: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The description of the format entry.
-        """
-        end_date: NotRequired[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.
-        """
-        end_length: NotRequired[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.
-        """
-        end_value: NotRequired[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.
-        """
-        fixed_number: NotRequired[pulumi.Input[float]]
-        """
-        (Updatable) The constant number to be used for masking.
-        """
-        fixed_string: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The constant string to be used for masking.
-        """
-        grouping_columns: NotRequired[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.
-        """
-        length: NotRequired[pulumi.Input[int]]
-        """
-        (Updatable) The number of characters that should be there in the substring. It should be an integer and greater than zero.
-        """
-        library_masking_format_id: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The OCID of the library masking format.
-        """
-        pattern: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The pattern that should be used to mask data.
-        """
-        post_processing_function: NotRequired[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.
-        """
-        random_lists: NotRequired[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.
-        """
-        regular_expression: NotRequired[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.
-        """
-        replace_with: NotRequired[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.
-        """
-        schema_name: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The name of the schema that contains the substitution column.
-        """
-        sql_expression: NotRequired[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.
-        """
-        start_date: NotRequired[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.
-        """
-        start_length: NotRequired[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.
-        """
-        start_position: NotRequired[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.
-        """
-        start_value: NotRequired[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.
-        """
-        table_name: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The name of the table that contains the substitution column.
-        """
-        user_defined_function: NotRequired[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.
-        """
-elif False:
-    MaskingPoliciesMaskingColumnMaskingFormatFormatEntryArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class MaskingPoliciesMaskingColumnMaskingFormatFormatEntryArgs:
     def __init__(__self__, *,
@@ -3268,23 +2488,6 @@ class MaskingPoliciesMaskingColumnMaskingFormatFormatEntryArgs:
         pulumi.set(self, "user_defined_function", value)
 
 
-if not MYPY:
-    class MaskingPolicyColumnSourceArgsDict(TypedDict):
-        column_source: pulumi.Input[str]
-        """
-        (Updatable) The source of masking columns.
-        """
-        sensitive_data_model_id: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The OCID of the sensitive data model to be associated as the column source with the masking policy.
-        """
-        target_id: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The OCID of the target database to be associated as the column source with the masking policy.
-        """
-elif False:
-    MaskingPolicyColumnSourceArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class MaskingPolicyColumnSourceArgs:
     def __init__(__self__, *,
@@ -3339,31 +2542,6 @@ class MaskingPolicyColumnSourceArgs:
         pulumi.set(self, "target_id", value)
 
 
-if not MYPY:
-    class ReportDefinitionColumnFilterArgsDict(TypedDict):
-        expressions: pulumi.Input[Sequence[pulumi.Input[str]]]
-        """
-        (Updatable) An array of expressions based on the operator type. A filter may have one or more expressions.
-        """
-        field_name: pulumi.Input[str]
-        """
-        (Updatable) Name of the column on which the filter must be applied.
-        """
-        is_enabled: pulumi.Input[bool]
-        """
-        (Updatable) Indicates whether the filter is enabled. Values can either be 'true' or 'false'.
-        """
-        is_hidden: pulumi.Input[bool]
-        """
-        (Updatable) Indicates whether the filter is hidden. Values can either be 'true' or 'false'.
-        """
-        operator: pulumi.Input[str]
-        """
-        (Updatable) Specifies the type of operator that must be applied for example in, eq etc.
-        """
-elif False:
-    ReportDefinitionColumnFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ReportDefinitionColumnFilterArgs:
     def __init__(__self__, *,
@@ -3446,31 +2624,6 @@ class ReportDefinitionColumnFilterArgs:
         pulumi.set(self, "operator", value)
 
 
-if not MYPY:
-    class ReportDefinitionColumnInfoArgsDict(TypedDict):
-        display_name: pulumi.Input[str]
-        """
-        (Updatable) Name of the column displayed on UI.
-        """
-        display_order: pulumi.Input[int]
-        """
-        (Updatable) Specifies the display order of the column.
-        """
-        field_name: pulumi.Input[str]
-        """
-        (Updatable) Specifies the corresponding field name in the data source.
-        """
-        is_hidden: pulumi.Input[bool]
-        """
-        (Updatable) Indicates if the column is hidden. Values can either be 'true' or 'false'.
-        """
-        data_type: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) Specifies the data type of the column.
-        """
-elif False:
-    ReportDefinitionColumnInfoArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ReportDefinitionColumnInfoArgs:
     def __init__(__self__, *,
@@ -3554,23 +2707,6 @@ class ReportDefinitionColumnInfoArgs:
         pulumi.set(self, "data_type", value)
 
 
-if not MYPY:
-    class ReportDefinitionColumnSortingArgsDict(TypedDict):
-        field_name: pulumi.Input[str]
-        """
-        (Updatable) Name of the column that must be sorted.
-        """
-        is_ascending: pulumi.Input[bool]
-        """
-        (Updatable) Indicates if the column must be sorted in ascending order. Values can either be 'true' or 'false'.
-        """
-        sorting_order: pulumi.Input[int]
-        """
-        (Updatable) Indicates the order at which column must be sorted.
-        """
-elif False:
-    ReportDefinitionColumnSortingArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ReportDefinitionColumnSortingArgs:
     def __init__(__self__, *,
@@ -3623,39 +2759,6 @@ class ReportDefinitionColumnSortingArgs:
         pulumi.set(self, "sorting_order", value)
 
 
-if not MYPY:
-    class ReportDefinitionSummaryArgsDict(TypedDict):
-        display_order: pulumi.Input[int]
-        """
-        (Updatable) Specifies the order in which the summary must be displayed.
-        """
-        name: pulumi.Input[str]
-        """
-        (Updatable) Name of the report summary.
-        """
-        count_of: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) Name of the key or count of object.
-        """
-        group_by_field_name: NotRequired[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.
-        """
-        is_hidden: NotRequired[pulumi.Input[bool]]
-        """
-        (Updatable) Indicates if the summary is hidden. Values can either be 'true' or 'false'.
-        """
-        scim_filter: NotRequired[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
-        """
-elif False:
-    ReportDefinitionSummaryArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ReportDefinitionSummaryArgs:
     def __init__(__self__, *,
@@ -3765,43 +2868,6 @@ class ReportDefinitionSummaryArgs:
         pulumi.set(self, "scim_filter", value)
 
 
-if not MYPY:
-    class SecurityAssessmentStatisticArgsDict(TypedDict):
-        advisories: NotRequired[pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticAdvisoryArgsDict']]]]
-        """
-        Statistics showing the number of findings with a particular risk level for each category.
-        """
-        deferreds: NotRequired[pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticDeferredArgsDict']]]]
-        """
-        Statistics showing the number of findings with a particular risk level for each category.
-        """
-        evaluates: NotRequired[pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticEvaluateArgsDict']]]]
-        """
-        Statistics showing the number of findings with a particular risk level for each category.
-        """
-        high_risks: NotRequired[pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticHighRiskArgsDict']]]]
-        """
-        Statistics showing the number of findings with a particular risk level for each category.
-        """
-        low_risks: NotRequired[pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticLowRiskArgsDict']]]]
-        """
-        Statistics showing the number of findings with a particular risk level for each category.
-        """
-        medium_risks: NotRequired[pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticMediumRiskArgsDict']]]]
-        """
-        Statistics showing the number of findings with a particular risk level for each category.
-        """
-        passes: NotRequired[pulumi.Input[Sequence[pulumi.Input['SecurityAssessmentStatisticPassArgsDict']]]]
-        """
-        Statistics showing the number of findings with a particular risk level for each category.
-        """
-        targets_count: NotRequired[pulumi.Input[int]]
-        """
-        The total number of targets in this security assessment.
-        """
-elif False:
-    SecurityAssessmentStatisticArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class SecurityAssessmentStatisticArgs:
     def __init__(__self__, *,
@@ -3937,43 +3003,6 @@ class SecurityAssessmentStatisticArgs:
         pulumi.set(self, "targets_count", value)
 
 
-if not MYPY:
-    class SecurityAssessmentStatisticAdvisoryArgsDict(TypedDict):
-        auditing_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Auditing category.
-        """
-        authorization_control_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Authorization Control category.
-        """
-        data_encryption_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Data Encryption category.
-        """
-        db_configuration_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Database Configuration category.
-        """
-        fine_grained_access_control_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Fine-Grained Access Control category.
-        """
-        privileges_and_roles_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Privileges and Roles category.
-        """
-        targets_count: NotRequired[pulumi.Input[int]]
-        """
-        The total number of targets in this security assessment.
-        """
-        user_accounts_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the User Accounts category.
-        """
-elif False:
-    SecurityAssessmentStatisticAdvisoryArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class SecurityAssessmentStatisticAdvisoryArgs:
     def __init__(__self__, *,
@@ -4109,43 +3138,6 @@ class SecurityAssessmentStatisticAdvisoryArgs:
         pulumi.set(self, "user_accounts_findings_count", value)
 
 
-if not MYPY:
-    class SecurityAssessmentStatisticDeferredArgsDict(TypedDict):
-        auditing_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Auditing category.
-        """
-        authorization_control_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Authorization Control category.
-        """
-        data_encryption_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Data Encryption category.
-        """
-        db_configuration_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Database Configuration category.
-        """
-        fine_grained_access_control_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Fine-Grained Access Control category.
-        """
-        privileges_and_roles_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Privileges and Roles category.
-        """
-        targets_count: NotRequired[pulumi.Input[int]]
-        """
-        The total number of targets in this security assessment.
-        """
-        user_accounts_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the User Accounts category.
-        """
-elif False:
-    SecurityAssessmentStatisticDeferredArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class SecurityAssessmentStatisticDeferredArgs:
     def __init__(__self__, *,
@@ -4281,43 +3273,6 @@ class SecurityAssessmentStatisticDeferredArgs:
         pulumi.set(self, "user_accounts_findings_count", value)
 
 
-if not MYPY:
-    class SecurityAssessmentStatisticEvaluateArgsDict(TypedDict):
-        auditing_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Auditing category.
-        """
-        authorization_control_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Authorization Control category.
-        """
-        data_encryption_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Data Encryption category.
-        """
-        db_configuration_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Database Configuration category.
-        """
-        fine_grained_access_control_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Fine-Grained Access Control category.
-        """
-        privileges_and_roles_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Privileges and Roles category.
-        """
-        targets_count: NotRequired[pulumi.Input[int]]
-        """
-        The total number of targets in this security assessment.
-        """
-        user_accounts_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the User Accounts category.
-        """
-elif False:
-    SecurityAssessmentStatisticEvaluateArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class SecurityAssessmentStatisticEvaluateArgs:
     def __init__(__self__, *,
@@ -4453,43 +3408,6 @@ class SecurityAssessmentStatisticEvaluateArgs:
         pulumi.set(self, "user_accounts_findings_count", value)
 
 
-if not MYPY:
-    class SecurityAssessmentStatisticHighRiskArgsDict(TypedDict):
-        auditing_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Auditing category.
-        """
-        authorization_control_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Authorization Control category.
-        """
-        data_encryption_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Data Encryption category.
-        """
-        db_configuration_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Database Configuration category.
-        """
-        fine_grained_access_control_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Fine-Grained Access Control category.
-        """
-        privileges_and_roles_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Privileges and Roles category.
-        """
-        targets_count: NotRequired[pulumi.Input[int]]
-        """
-        The total number of targets in this security assessment.
-        """
-        user_accounts_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the User Accounts category.
-        """
-elif False:
-    SecurityAssessmentStatisticHighRiskArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class SecurityAssessmentStatisticHighRiskArgs:
     def __init__(__self__, *,
@@ -4625,43 +3543,6 @@ class SecurityAssessmentStatisticHighRiskArgs:
         pulumi.set(self, "user_accounts_findings_count", value)
 
 
-if not MYPY:
-    class SecurityAssessmentStatisticLowRiskArgsDict(TypedDict):
-        auditing_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Auditing category.
-        """
-        authorization_control_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Authorization Control category.
-        """
-        data_encryption_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Data Encryption category.
-        """
-        db_configuration_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Database Configuration category.
-        """
-        fine_grained_access_control_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Fine-Grained Access Control category.
-        """
-        privileges_and_roles_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Privileges and Roles category.
-        """
-        targets_count: NotRequired[pulumi.Input[int]]
-        """
-        The total number of targets in this security assessment.
-        """
-        user_accounts_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the User Accounts category.
-        """
-elif False:
-    SecurityAssessmentStatisticLowRiskArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class SecurityAssessmentStatisticLowRiskArgs:
     def __init__(__self__, *,
@@ -4797,43 +3678,6 @@ class SecurityAssessmentStatisticLowRiskArgs:
         pulumi.set(self, "user_accounts_findings_count", value)
 
 
-if not MYPY:
-    class SecurityAssessmentStatisticMediumRiskArgsDict(TypedDict):
-        auditing_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Auditing category.
-        """
-        authorization_control_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Authorization Control category.
-        """
-        data_encryption_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Data Encryption category.
-        """
-        db_configuration_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Database Configuration category.
-        """
-        fine_grained_access_control_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Fine-Grained Access Control category.
-        """
-        privileges_and_roles_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Privileges and Roles category.
-        """
-        targets_count: NotRequired[pulumi.Input[int]]
-        """
-        The total number of targets in this security assessment.
-        """
-        user_accounts_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the User Accounts category.
-        """
-elif False:
-    SecurityAssessmentStatisticMediumRiskArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class SecurityAssessmentStatisticMediumRiskArgs:
     def __init__(__self__, *,
@@ -4969,43 +3813,6 @@ class SecurityAssessmentStatisticMediumRiskArgs:
         pulumi.set(self, "user_accounts_findings_count", value)
 
 
-if not MYPY:
-    class SecurityAssessmentStatisticPassArgsDict(TypedDict):
-        auditing_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Auditing category.
-        """
-        authorization_control_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Authorization Control category.
-        """
-        data_encryption_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Data Encryption category.
-        """
-        db_configuration_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Database Configuration category.
-        """
-        fine_grained_access_control_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Fine-Grained Access Control category.
-        """
-        privileges_and_roles_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the Privileges and Roles category.
-        """
-        targets_count: NotRequired[pulumi.Input[int]]
-        """
-        The total number of targets in this security assessment.
-        """
-        user_accounts_findings_count: NotRequired[pulumi.Input[int]]
-        """
-        The number of findings in the User Accounts category.
-        """
-elif False:
-    SecurityAssessmentStatisticPassArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class SecurityAssessmentStatisticPassArgs:
     def __init__(__self__, *,
@@ -5141,19 +3948,6 @@ class SecurityAssessmentStatisticPassArgs:
         pulumi.set(self, "user_accounts_findings_count", value)
 
 
-if not MYPY:
-    class SensitiveDataModelTablesForDiscoveryArgsDict(TypedDict):
-        schema_name: pulumi.Input[str]
-        """
-        (Updatable) This contains the name of the schema.
-        """
-        table_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        (Updatable) This contains an optional list of the table names.
-        """
-elif False:
-    SensitiveDataModelTablesForDiscoveryArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class SensitiveDataModelTablesForDiscoveryArgs:
     def __init__(__self__, *,
@@ -5192,25 +3986,6 @@ class SensitiveDataModelTablesForDiscoveryArgs:
         pulumi.set(self, "table_names", value)
 
 
-if not MYPY:
-    class TargetDatabaseConnectionOptionArgsDict(TypedDict):
-        connection_type: 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.
-        """
-        datasafe_private_endpoint_id: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The OCID of the Data Safe private endpoint.
-        """
-        on_prem_connector_id: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The OCID of the on-premises connector.
-        """
-elif False:
-    TargetDatabaseConnectionOptionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class TargetDatabaseConnectionOptionArgs:
     def __init__(__self__, *,
@@ -5269,19 +4044,6 @@ class TargetDatabaseConnectionOptionArgs:
         pulumi.set(self, "on_prem_connector_id", value)
 
 
-if not MYPY:
-    class TargetDatabaseCredentialsArgsDict(TypedDict):
-        password: pulumi.Input[str]
-        """
-        (Updatable) The password of the database user.
-        """
-        user_name: pulumi.Input[str]
-        """
-        (Updatable) The database user name.
-        """
-elif False:
-    TargetDatabaseCredentialsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class TargetDatabaseCredentialsArgs:
     def __init__(__self__, *,
@@ -5319,47 +4081,6 @@ class TargetDatabaseCredentialsArgs:
         pulumi.set(self, "user_name", value)
 
 
-if not MYPY:
-    class TargetDatabaseDatabaseDetailsArgsDict(TypedDict):
-        database_type: pulumi.Input[str]
-        """
-        (Updatable) The database type.
-        """
-        infrastructure_type: pulumi.Input[str]
-        """
-        (Updatable) The infrastructure type the database is running on.
-        """
-        autonomous_database_id: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The OCID of the Autonomous Database registered as a target database in Data Safe.
-        """
-        db_system_id: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The OCID of the cloud database registered as a target database in Data Safe.
-        """
-        instance_id: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The OCID of the compute instance on which the database is running.
-        """
-        ip_addresses: NotRequired[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'.
-        """
-        listener_port: NotRequired[pulumi.Input[int]]
-        """
-        (Updatable) The port number of the database listener.
-        """
-        service_name: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The service name of the database registered as target database.
-        """
-        vm_cluster_id: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The OCID of the VM cluster in which the database is running.
-        """
-elif False:
-    TargetDatabaseDatabaseDetailsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class TargetDatabaseDatabaseDetailsArgs:
     def __init__(__self__, *,
@@ -5509,55 +4230,6 @@ class TargetDatabaseDatabaseDetailsArgs:
         pulumi.set(self, "vm_cluster_id", value)
 
 
-if not MYPY:
-    class TargetDatabasePeerTargetDatabaseArgsDict(TypedDict):
-        database_details: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetDatabasePeerTargetDatabaseDatabaseDetailArgsDict']]]]
-        """
-        (Updatable) Details of the database for the registration in Data Safe.
-        """
-        database_unique_name: NotRequired[pulumi.Input[str]]
-        """
-        Unique name of the database associated to the peer target database.
-        """
-        dataguard_association_id: NotRequired[pulumi.Input[str]]
-        """
-        The OCID of the Data Guard Association resource in which the database associated to the peer target database is considered as peer database to the primary database.
-        """
-        description: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The description of the target database in Data Safe.
-        """
-        display_name: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The display name of the target database in Data Safe. The name is modifiable and does not need to be unique.
-        """
-        key: NotRequired[pulumi.Input[int]]
-        """
-        The secondary key assigned for the peer target database in Data Safe.
-        """
-        lifecycle_details: NotRequired[pulumi.Input[str]]
-        """
-        Details about the current state of the peer target database in Data Safe.
-        """
-        role: NotRequired[pulumi.Input[str]]
-        """
-        Role of the database associated to the peer target database.
-        """
-        state: NotRequired[pulumi.Input[str]]
-        """
-        The current state of the target database in Data Safe.
-        """
-        time_created: NotRequired[pulumi.Input[str]]
-        """
-        The date and time the database was registered in Data Safe and created as a target database in Data Safe.
-        """
-        tls_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetDatabasePeerTargetDatabaseTlsConfigArgsDict']]]]
-        """
-        (Updatable) The details required to establish a TLS enabled connection.
-        """
-elif False:
-    TargetDatabasePeerTargetDatabaseArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class TargetDatabasePeerTargetDatabaseArgs:
     def __init__(__self__, *,
@@ -5741,47 +4413,6 @@ class TargetDatabasePeerTargetDatabaseArgs:
         pulumi.set(self, "tls_configs", value)
 
 
-if not MYPY:
-    class TargetDatabasePeerTargetDatabaseDatabaseDetailArgsDict(TypedDict):
-        autonomous_database_id: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The OCID of the Autonomous Database registered as a target database in Data Safe.
-        """
-        database_type: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The database type.
-        """
-        db_system_id: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The OCID of the cloud database registered as a target database in Data Safe.
-        """
-        infrastructure_type: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The infrastructure type the database is running on.
-        """
-        instance_id: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The OCID of the compute instance on which the database is running.
-        """
-        ip_addresses: NotRequired[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'.
-        """
-        listener_port: NotRequired[pulumi.Input[int]]
-        """
-        (Updatable) The port number of the database listener.
-        """
-        service_name: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The service name of the database registered as target database.
-        """
-        vm_cluster_id: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The OCID of the VM cluster in which the database is running.
-        """
-elif False:
-    TargetDatabasePeerTargetDatabaseDatabaseDetailArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class TargetDatabasePeerTargetDatabaseDatabaseDetailArgs:
     def __init__(__self__, *,
@@ -5933,47 +4564,6 @@ class TargetDatabasePeerTargetDatabaseDatabaseDetailArgs:
         pulumi.set(self, "vm_cluster_id", value)
 
 
-if not MYPY:
-    class TargetDatabasePeerTargetDatabaseDatabaseDetailsArgsDict(TypedDict):
-        database_type: pulumi.Input[str]
-        """
-        (Updatable) The database type.
-        """
-        infrastructure_type: pulumi.Input[str]
-        """
-        (Updatable) The infrastructure type the database is running on.
-        """
-        autonomous_database_id: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The OCID of the Autonomous Database registered as a target database in Data Safe.
-        """
-        db_system_id: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The OCID of the cloud database registered as a target database in Data Safe.
-        """
-        instance_id: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The OCID of the compute instance on which the database is running.
-        """
-        ip_addresses: NotRequired[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'.
-        """
-        listener_port: NotRequired[pulumi.Input[int]]
-        """
-        (Updatable) The port number of the database listener.
-        """
-        service_name: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The service name of the database registered as target database.
-        """
-        vm_cluster_id: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The OCID of the VM cluster in which the database is running.
-        """
-elif False:
-    TargetDatabasePeerTargetDatabaseDatabaseDetailsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class TargetDatabasePeerTargetDatabaseDatabaseDetailsArgs:
     def __init__(__self__, *,
@@ -6123,31 +4713,6 @@ class TargetDatabasePeerTargetDatabaseDatabaseDetailsArgs:
         pulumi.set(self, "vm_cluster_id", value)
 
 
-if not MYPY:
-    class TargetDatabasePeerTargetDatabaseDetailArgsDict(TypedDict):
-        database_details: pulumi.Input['TargetDatabasePeerTargetDatabaseDetailDatabaseDetailsArgsDict']
-        """
-        Details of the database for the registration in Data Safe.
-        """
-        dataguard_association_id: NotRequired[pulumi.Input[str]]
-        """
-        The OCID of the Data Guard Association resource in which the database being registered is considered as peer database to the primary database.
-        """
-        description: NotRequired[pulumi.Input[str]]
-        """
-        The description of the peer target database in Data Safe.
-        """
-        display_name: NotRequired[pulumi.Input[str]]
-        """
-        The display name of the peer target database in Data Safe. The name is modifiable and does not need to be unique.
-        """
-        tls_config: NotRequired[pulumi.Input['TargetDatabasePeerTargetDatabaseDetailTlsConfigArgsDict']]
-        """
-        The details required to establish a TLS enabled connection.
-        """
-elif False:
-    TargetDatabasePeerTargetDatabaseDetailArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class TargetDatabasePeerTargetDatabaseDetailArgs:
     def __init__(__self__, *,
@@ -6234,47 +4799,6 @@ class TargetDatabasePeerTargetDatabaseDetailArgs:
         pulumi.set(self, "tls_config", value)
 
 
-if not MYPY:
-    class TargetDatabasePeerTargetDatabaseDetailDatabaseDetailsArgsDict(TypedDict):
-        database_type: pulumi.Input[str]
-        """
-        The database type.
-        """
-        infrastructure_type: pulumi.Input[str]
-        """
-        The infrastructure type the database is running on.
-        """
-        autonomous_database_id: NotRequired[pulumi.Input[str]]
-        """
-        The OCID of the Autonomous Database registered as a target database in Data Safe.
-        """
-        db_system_id: NotRequired[pulumi.Input[str]]
-        """
-        The OCID of the cloud database registered as a target database in Data Safe.
-        """
-        instance_id: NotRequired[pulumi.Input[str]]
-        """
-        The OCID of the compute instance on which the database is running.
-        """
-        ip_addresses: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        The list of database host IP Addresses. Fully qualified domain names can be used if connectionType is 'ONPREM_CONNECTOR'.
-        """
-        listener_port: NotRequired[pulumi.Input[int]]
-        """
-        The port number of the database listener.
-        """
-        service_name: NotRequired[pulumi.Input[str]]
-        """
-        The service name of the database registered as target database.
-        """
-        vm_cluster_id: NotRequired[pulumi.Input[str]]
-        """
-        The OCID of the VM cluster in which the database is running.
-        """
-elif False:
-    TargetDatabasePeerTargetDatabaseDetailDatabaseDetailsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class TargetDatabasePeerTargetDatabaseDetailDatabaseDetailsArgs:
     def __init__(__self__, *,
@@ -6424,31 +4948,6 @@ class TargetDatabasePeerTargetDatabaseDetailDatabaseDetailsArgs:
         pulumi.set(self, "vm_cluster_id", value)
 
 
-if not MYPY:
-    class TargetDatabasePeerTargetDatabaseDetailTlsConfigArgsDict(TypedDict):
-        status: pulumi.Input[str]
-        """
-        Status to represent whether the database connection is TLS enabled or not.
-        """
-        certificate_store_type: NotRequired[pulumi.Input[str]]
-        """
-        The format of the certificate store.
-        """
-        key_store_content: NotRequired[pulumi.Input[str]]
-        """
-        Base64 encoded string of key store file content.
-        """
-        store_password: NotRequired[pulumi.Input[str]]
-        """
-        The password to read the trust store and key store files, if they are password protected.
-        """
-        trust_store_content: NotRequired[pulumi.Input[str]]
-        """
-        Base64 encoded string of trust store file content.
-        """
-elif False:
-    TargetDatabasePeerTargetDatabaseDetailTlsConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class TargetDatabasePeerTargetDatabaseDetailTlsConfigArgs:
     def __init__(__self__, *,
@@ -6535,35 +5034,6 @@ class TargetDatabasePeerTargetDatabaseDetailTlsConfigArgs:
         pulumi.set(self, "trust_store_content", value)
 
 
-if not MYPY:
-    class TargetDatabasePeerTargetDatabaseTlsConfigArgsDict(TypedDict):
-        status: pulumi.Input[str]
-        """
-        (Updatable) Status to represent whether the database connection is TLS enabled or not.
-        """
-        certificate_store_type: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The format of the certificate store.
-        """
-        key_store_content: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) Base64 encoded string of key store file content.
-        """
-        store_password: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The password to read the trust store and key store files, if they are password protected.
-        """
-        trust_store_content: NotRequired[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
-        """
-elif False:
-    TargetDatabasePeerTargetDatabaseTlsConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class TargetDatabasePeerTargetDatabaseTlsConfigArgs:
     def __init__(__self__, *,
@@ -6658,35 +5128,6 @@ class TargetDatabasePeerTargetDatabaseTlsConfigArgs:
         pulumi.set(self, "trust_store_content", value)
 
 
-if not MYPY:
-    class TargetDatabaseTlsConfigArgsDict(TypedDict):
-        status: pulumi.Input[str]
-        """
-        (Updatable) Status to represent whether the database connection is TLS enabled or not.
-        """
-        certificate_store_type: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The format of the certificate store.
-        """
-        key_store_content: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) Base64 encoded string of key store file content.
-        """
-        store_password: NotRequired[pulumi.Input[str]]
-        """
-        (Updatable) The password to read the trust store and key store files, if they are password protected.
-        """
-        trust_store_content: NotRequired[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
-        """
-elif False:
-    TargetDatabaseTlsConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class TargetDatabaseTlsConfigArgs:
     def __init__(__self__, *,
@@ -6760,530 +5201,84 @@ class TargetDatabaseTlsConfigArgs:
         """
         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)
-
-
-if not MYPY:
-    class UserAssessmentIgnoredTargetArgsDict(TypedDict):
-        lifecycle_state: NotRequired[pulumi.Input[str]]
-        target_id: NotRequired[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
-        """
-        user_assessment_id: NotRequired[pulumi.Input[str]]
-elif False:
-    UserAssessmentIgnoredTargetArgsDict: TypeAlias = Mapping[str, Any]
-
-@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)
-
-
-if not MYPY:
-    class GetAlertPoliciesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetAlertPoliciesFilterArgsDict: TypeAlias = Mapping[str, Any]
-
-@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)
-
-
-if not MYPY:
-    class GetAlertPolicyRulesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetAlertPolicyRulesFilterArgsDict: TypeAlias = Mapping[str, Any]
-
-@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)
-
-
-if not MYPY:
-    class GetAlertsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetAlertsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
-@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)
-
-
-if not MYPY:
-    class GetAuditArchiveRetrievalsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetAuditArchiveRetrievalsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
-@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)
-
-
-if not MYPY:
-    class GetAuditEventsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetAuditEventsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
-@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)
-
-
-if not MYPY:
-    class GetAuditPoliciesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetAuditPoliciesFilterArgsDict: TypeAlias = Mapping[str, Any]
-
-@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)
-
-
-if not MYPY:
-    class GetAuditProfileAvailableAuditVolumesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetAuditProfileAvailableAuditVolumesFilterArgsDict: TypeAlias = Mapping[str, Any]
-
-@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)
-
-
-if not MYPY:
-    class GetAuditProfileCollectedAuditVolumesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetAuditProfileCollectedAuditVolumesFilterArgsDict: TypeAlias = Mapping[str, Any]
-
-@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)
+    @store_password.setter
+    def store_password(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "store_password", value)
 
     @property
-    @pulumi.getter
-    def regex(self) -> Optional[bool]:
-        return pulumi.get(self, "regex")
+    @pulumi.getter(name="trustStoreContent")
+    def trust_store_content(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) Base64 encoded string of trust store file content.
 
-    @regex.setter
-    def regex(self, value: Optional[bool]):
-        pulumi.set(self, "regex", value)
 
+        ** 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)
 
-if not MYPY:
-    class GetAuditProfilesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetAuditProfilesFilterArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class GetAuditProfilesFilterArgs:
+class UserAssessmentIgnoredTargetArgs:
     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)
+                 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
-    def name(self) -> str:
-        return pulumi.get(self, "name")
+    @pulumi.getter(name="lifecycleState")
+    def lifecycle_state(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "lifecycle_state")
 
-    @name.setter
-    def name(self, value: str):
-        pulumi.set(self, "name", value)
+    @lifecycle_state.setter
+    def lifecycle_state(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "lifecycle_state", value)
 
     @property
-    @pulumi.getter
-    def values(self) -> Sequence[str]:
-        return pulumi.get(self, "values")
+    @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.
 
-    @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")
+        ** 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")
 
-    @regex.setter
-    def regex(self, value: Optional[bool]):
-        pulumi.set(self, "regex", value)
+    @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)
 
-if not MYPY:
-    class GetAuditTrailsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetAuditTrailsFilterArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class GetAuditTrailsFilterArgs:
+class GetAlertPoliciesFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -7321,16 +5316,8 @@ class GetAuditTrailsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetDataSafePrivateEndpointsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetDataSafePrivateEndpointsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetDataSafePrivateEndpointsFilterArgs:
+class GetAlertPolicyRulesFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -7368,16 +5355,8 @@ class GetDataSafePrivateEndpointsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetDiscoveryAnalyticsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetDiscoveryAnalyticsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetDiscoveryAnalyticsFilterArgs:
+class GetAlertsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -7415,16 +5394,8 @@ class GetDiscoveryAnalyticsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetDiscoveryJobsResultsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetDiscoveryJobsResultsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetDiscoveryJobsResultsFilterArgs:
+class GetAuditArchiveRetrievalsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -7462,16 +5433,8 @@ class GetDiscoveryJobsResultsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetLibraryMaskingFormatsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetLibraryMaskingFormatsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetLibraryMaskingFormatsFilterArgs:
+class GetAuditEventsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -7509,16 +5472,8 @@ class GetLibraryMaskingFormatsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetListUserGrantsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetListUserGrantsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetListUserGrantsFilterArgs:
+class GetAuditPoliciesFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -7556,16 +5511,8 @@ class GetListUserGrantsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetMaskingAnalyticsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetMaskingAnalyticsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetMaskingAnalyticsFilterArgs:
+class GetAuditProfileAvailableAuditVolumesFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -7603,16 +5550,8 @@ class GetMaskingAnalyticsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetMaskingPoliciesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetMaskingPoliciesFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetMaskingPoliciesFilterArgs:
+class GetAuditProfileCollectedAuditVolumesFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -7650,16 +5589,8 @@ class GetMaskingPoliciesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetMaskingPoliciesMaskingColumnsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetMaskingPoliciesMaskingColumnsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetMaskingPoliciesMaskingColumnsFilterArgs:
+class GetAuditProfilesFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -7697,16 +5628,8 @@ class GetMaskingPoliciesMaskingColumnsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetMaskingPolicyHealthReportLogsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetMaskingPolicyHealthReportLogsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetMaskingPolicyHealthReportLogsFilterArgs:
+class GetAuditTrailsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -7744,16 +5667,8 @@ class GetMaskingPolicyHealthReportLogsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetMaskingPolicyHealthReportsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetMaskingPolicyHealthReportsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetMaskingPolicyHealthReportsFilterArgs:
+class GetDataSafePrivateEndpointsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -7791,16 +5706,8 @@ class GetMaskingPolicyHealthReportsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetMaskingPolicyMaskingObjectsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetMaskingPolicyMaskingObjectsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetMaskingPolicyMaskingObjectsFilterArgs:
+class GetDiscoveryAnalyticsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -7838,16 +5745,8 @@ class GetMaskingPolicyMaskingObjectsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetMaskingPolicyMaskingSchemasFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetMaskingPolicyMaskingSchemasFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetMaskingPolicyMaskingSchemasFilterArgs:
+class GetDiscoveryJobsResultsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -7885,16 +5784,8 @@ class GetMaskingPolicyMaskingSchemasFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetMaskingReportMaskedColumnsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetMaskingReportMaskedColumnsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetMaskingReportMaskedColumnsFilterArgs:
+class GetLibraryMaskingFormatsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -7932,16 +5823,8 @@ class GetMaskingReportMaskedColumnsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetMaskingReportsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetMaskingReportsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetMaskingReportsFilterArgs:
+class GetListUserGrantsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -7979,16 +5862,8 @@ class GetMaskingReportsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetOnpremConnectorsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetOnpremConnectorsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetOnpremConnectorsFilterArgs:
+class GetMaskingAnalyticsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -8026,26 +5901,12 @@ class GetOnpremConnectorsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetReportDefinitionsFilterArgsDict(TypedDict):
-        name: str
-        """
-        Name of the report summary.
-        """
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetReportDefinitionsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetReportDefinitionsFilterArgs:
+class GetMaskingPoliciesFilterArgs:
     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:
@@ -8054,9 +5915,6 @@ class GetReportDefinitionsFilterArgs:
     @property
     @pulumi.getter
     def name(self) -> str:
-        """
-        Name of the report summary.
-        """
         return pulumi.get(self, "name")
 
     @name.setter
@@ -8082,16 +5940,8 @@ class GetReportDefinitionsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetReportsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetReportsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetReportsFilterArgs:
+class GetMaskingPoliciesMaskingColumnsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -8129,16 +5979,8 @@ class GetReportsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSdmMaskingPolicyDifferenceDifferenceColumnsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSdmMaskingPolicyDifferenceDifferenceColumnsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSdmMaskingPolicyDifferenceDifferenceColumnsFilterArgs:
+class GetMaskingPolicyHealthReportLogsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -8176,16 +6018,8 @@ class GetSdmMaskingPolicyDifferenceDifferenceColumnsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSdmMaskingPolicyDifferencesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSdmMaskingPolicyDifferencesFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSdmMaskingPolicyDifferencesFilterArgs:
+class GetMaskingPolicyHealthReportsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -8223,16 +6057,8 @@ class GetSdmMaskingPolicyDifferencesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSecurityAssessmentFindingAnalyticsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSecurityAssessmentFindingAnalyticsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSecurityAssessmentFindingAnalyticsFilterArgs:
+class GetMaskingPolicyMaskingObjectsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -8270,16 +6096,8 @@ class GetSecurityAssessmentFindingAnalyticsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSecurityAssessmentFindingFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSecurityAssessmentFindingFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSecurityAssessmentFindingFilterArgs:
+class GetMaskingPolicyMaskingSchemasFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -8317,16 +6135,8 @@ class GetSecurityAssessmentFindingFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSecurityAssessmentFindingsChangeAuditLogsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSecurityAssessmentFindingsChangeAuditLogsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSecurityAssessmentFindingsChangeAuditLogsFilterArgs:
+class GetMaskingReportMaskedColumnsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -8364,16 +6174,8 @@ class GetSecurityAssessmentFindingsChangeAuditLogsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSecurityAssessmentFindingsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSecurityAssessmentFindingsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSecurityAssessmentFindingsFilterArgs:
+class GetMaskingReportsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -8411,16 +6213,8 @@ class GetSecurityAssessmentFindingsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSecurityAssessmentSecurityFeatureAnalyticsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSecurityAssessmentSecurityFeatureAnalyticsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSecurityAssessmentSecurityFeatureAnalyticsFilterArgs:
+class GetOnpremConnectorsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -8458,20 +6252,15 @@ class GetSecurityAssessmentSecurityFeatureAnalyticsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSecurityAssessmentSecurityFeaturesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSecurityAssessmentSecurityFeaturesFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSecurityAssessmentSecurityFeaturesFilterArgs:
+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:
@@ -8480,6 +6269,9 @@ class GetSecurityAssessmentSecurityFeaturesFilterArgs:
     @property
     @pulumi.getter
     def name(self) -> str:
+        """
+        Name of the report summary.
+        """
         return pulumi.get(self, "name")
 
     @name.setter
@@ -8505,16 +6297,8 @@ class GetSecurityAssessmentSecurityFeaturesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSecurityAssessmentsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSecurityAssessmentsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSecurityAssessmentsFilterArgs:
+class GetReportsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -8552,16 +6336,8 @@ class GetSecurityAssessmentsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSecurityPoliciesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSecurityPoliciesFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSecurityPoliciesFilterArgs:
+class GetSdmMaskingPolicyDifferenceDifferenceColumnsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -8599,16 +6375,8 @@ class GetSecurityPoliciesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSecurityPolicyDeploymentSecurityPolicyEntryStatesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSecurityPolicyDeploymentSecurityPolicyEntryStatesFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSecurityPolicyDeploymentSecurityPolicyEntryStatesFilterArgs:
+class GetSdmMaskingPolicyDifferencesFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -8646,16 +6414,8 @@ class GetSecurityPolicyDeploymentSecurityPolicyEntryStatesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSecurityPolicyDeploymentsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSecurityPolicyDeploymentsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSecurityPolicyDeploymentsFilterArgs:
+class GetSecurityAssessmentFindingAnalyticsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -8693,16 +6453,8 @@ class GetSecurityPolicyDeploymentsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSecurityPolicyReportDatabaseTableAccessEntriesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSecurityPolicyReportDatabaseTableAccessEntriesFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSecurityPolicyReportDatabaseTableAccessEntriesFilterArgs:
+class GetSecurityAssessmentFindingFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -8740,16 +6492,8 @@ class GetSecurityPolicyReportDatabaseTableAccessEntriesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSecurityPolicyReportDatabaseViewAccessEntriesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSecurityPolicyReportDatabaseViewAccessEntriesFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSecurityPolicyReportDatabaseViewAccessEntriesFilterArgs:
+class GetSecurityAssessmentFindingsChangeAuditLogsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -8787,16 +6531,8 @@ class GetSecurityPolicyReportDatabaseViewAccessEntriesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSecurityPolicyReportRoleGrantPathsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSecurityPolicyReportRoleGrantPathsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSecurityPolicyReportRoleGrantPathsFilterArgs:
+class GetSecurityAssessmentFindingsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -8834,16 +6570,8 @@ class GetSecurityPolicyReportRoleGrantPathsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSecurityPolicyReportsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSecurityPolicyReportsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSecurityPolicyReportsFilterArgs:
+class GetSecurityAssessmentSecurityFeatureAnalyticsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -8881,16 +6609,8 @@ class GetSecurityPolicyReportsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSensitiveDataModelSensitiveObjectsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSensitiveDataModelSensitiveObjectsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSensitiveDataModelSensitiveObjectsFilterArgs:
+class GetSecurityAssessmentSecurityFeaturesFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -8928,16 +6648,8 @@ class GetSensitiveDataModelSensitiveObjectsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSensitiveDataModelSensitiveSchemasFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSensitiveDataModelSensitiveSchemasFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSensitiveDataModelSensitiveSchemasFilterArgs:
+class GetSecurityAssessmentsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -8975,16 +6687,8 @@ class GetSensitiveDataModelSensitiveSchemasFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSensitiveDataModelSensitiveTypesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSensitiveDataModelSensitiveTypesFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSensitiveDataModelSensitiveTypesFilterArgs:
+class GetSecurityPoliciesFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -9022,16 +6726,8 @@ class GetSensitiveDataModelSensitiveTypesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSensitiveDataModelsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSensitiveDataModelsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSensitiveDataModelsFilterArgs:
+class GetSecurityPolicyDeploymentSecurityPolicyEntryStatesFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -9069,16 +6765,8 @@ class GetSensitiveDataModelsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSensitiveDataModelsSensitiveColumnsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSensitiveDataModelsSensitiveColumnsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSensitiveDataModelsSensitiveColumnsFilterArgs:
+class GetSecurityPolicyDeploymentsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -9116,16 +6804,8 @@ class GetSensitiveDataModelsSensitiveColumnsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSensitiveTypesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSensitiveTypesFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSensitiveTypesFilterArgs:
+class GetSecurityPolicyReportDatabaseTableAccessEntriesFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -9163,16 +6843,8 @@ class GetSensitiveTypesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSqlCollectionAnalyticsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSqlCollectionAnalyticsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSqlCollectionAnalyticsFilterArgs:
+class GetSecurityPolicyReportDatabaseViewAccessEntriesFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -9210,16 +6882,8 @@ class GetSqlCollectionAnalyticsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSqlCollectionLogInsightsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSqlCollectionLogInsightsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSqlCollectionLogInsightsFilterArgs:
+class GetSecurityPolicyReportRoleGrantPathsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -9257,16 +6921,8 @@ class GetSqlCollectionLogInsightsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSqlCollectionsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSqlCollectionsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSqlCollectionsFilterArgs:
+class GetSecurityPolicyReportsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -9304,16 +6960,8 @@ class GetSqlCollectionsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSqlFirewallAllowedSqlAnalyticsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSqlFirewallAllowedSqlAnalyticsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSqlFirewallAllowedSqlAnalyticsFilterArgs:
+class GetSensitiveDataModelSensitiveObjectsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -9351,16 +6999,8 @@ class GetSqlFirewallAllowedSqlAnalyticsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSqlFirewallAllowedSqlsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSqlFirewallAllowedSqlsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSqlFirewallAllowedSqlsFilterArgs:
+class GetSensitiveDataModelSensitiveSchemasFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -9398,16 +7038,8 @@ class GetSqlFirewallAllowedSqlsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSqlFirewallPoliciesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSqlFirewallPoliciesFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSqlFirewallPoliciesFilterArgs:
+class GetSensitiveDataModelSensitiveTypesFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -9445,16 +7077,8 @@ class GetSqlFirewallPoliciesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSqlFirewallPolicyAnalyticsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSqlFirewallPolicyAnalyticsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSqlFirewallPolicyAnalyticsFilterArgs:
+class GetSensitiveDataModelsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -9492,16 +7116,8 @@ class GetSqlFirewallPolicyAnalyticsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSqlFirewallViolationAnalyticsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSqlFirewallViolationAnalyticsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSqlFirewallViolationAnalyticsFilterArgs:
+class GetSensitiveDataModelsSensitiveColumnsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -9539,16 +7155,8 @@ class GetSqlFirewallViolationAnalyticsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetSqlFirewallViolationsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetSqlFirewallViolationsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
-class GetSqlFirewallViolationsFilterArgs:
+class GetSensitiveTypesFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
@@ -9586,14 +7194,6 @@ class GetSqlFirewallViolationsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetTargetAlertPolicyAssociationsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetTargetAlertPolicyAssociationsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GetTargetAlertPolicyAssociationsFilterArgs:
     def __init__(__self__, *,
@@ -9633,14 +7233,6 @@ class GetTargetAlertPolicyAssociationsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetTargetDatabasePeerTargetDatabasesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetTargetDatabasePeerTargetDatabasesFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GetTargetDatabasePeerTargetDatabasesFilterArgs:
     def __init__(__self__, *,
@@ -9680,14 +7272,6 @@ class GetTargetDatabasePeerTargetDatabasesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetTargetDatabaseRoleFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetTargetDatabaseRoleFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GetTargetDatabaseRoleFilterArgs:
     def __init__(__self__, *,
@@ -9727,14 +7311,6 @@ class GetTargetDatabaseRoleFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetTargetDatabaseRolesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetTargetDatabaseRolesFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GetTargetDatabaseRolesFilterArgs:
     def __init__(__self__, *,
@@ -9774,14 +7350,6 @@ class GetTargetDatabaseRolesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetTargetDatabasesColumnsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetTargetDatabasesColumnsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GetTargetDatabasesColumnsFilterArgs:
     def __init__(__self__, *,
@@ -9821,14 +7389,6 @@ class GetTargetDatabasesColumnsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetTargetDatabasesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetTargetDatabasesFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GetTargetDatabasesFilterArgs:
     def __init__(__self__, *,
@@ -9868,14 +7428,6 @@ class GetTargetDatabasesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetTargetDatabasesSchemasFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetTargetDatabasesSchemasFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GetTargetDatabasesSchemasFilterArgs:
     def __init__(__self__, *,
@@ -9915,14 +7467,6 @@ class GetTargetDatabasesSchemasFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetTargetDatabasesTablesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetTargetDatabasesTablesFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GetTargetDatabasesTablesFilterArgs:
     def __init__(__self__, *,
@@ -9962,14 +7506,6 @@ class GetTargetDatabasesTablesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetUserAssessmentProfileAnalyticsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetUserAssessmentProfileAnalyticsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GetUserAssessmentProfileAnalyticsFilterArgs:
     def __init__(__self__, *,
@@ -10009,14 +7545,6 @@ class GetUserAssessmentProfileAnalyticsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetUserAssessmentProfilesFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetUserAssessmentProfilesFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GetUserAssessmentProfilesFilterArgs:
     def __init__(__self__, *,
@@ -10056,14 +7584,6 @@ class GetUserAssessmentProfilesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetUserAssessmentUserAccessAnalyticsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetUserAssessmentUserAccessAnalyticsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GetUserAssessmentUserAccessAnalyticsFilterArgs:
     def __init__(__self__, *,
@@ -10103,14 +7623,6 @@ class GetUserAssessmentUserAccessAnalyticsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetUserAssessmentUserAnalyticsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetUserAssessmentUserAnalyticsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GetUserAssessmentUserAnalyticsFilterArgs:
     def __init__(__self__, *,
@@ -10150,14 +7662,6 @@ class GetUserAssessmentUserAnalyticsFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetUserAssessmentUsersFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetUserAssessmentUsersFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GetUserAssessmentUsersFilterArgs:
     def __init__(__self__, *,
@@ -10197,14 +7701,6 @@ class GetUserAssessmentUsersFilterArgs:
         pulumi.set(self, "regex", value)
 
 
-if not MYPY:
-    class GetUserAssessmentsFilterArgsDict(TypedDict):
-        name: str
-        values: Sequence[str]
-        regex: NotRequired[bool]
-elif False:
-    GetUserAssessmentsFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GetUserAssessmentsFilterArgs:
     def __init__(__self__, *,