Package com.oracle.bmc.datasafe

Interface DataSafeAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    DataSafeAsyncClient
    @Generated(value="OracleSDKGenerator",
           comments="API Version: 20181201")
public interface DataSafeAsync
extends AutoCloseable
    APIs for using Oracle Data Safe.

    • Method Detail

      • refreshClient

        void refreshClient()
        Rebuilds the client from scratch.

        Useful to refresh certificates.

      • setEndpoint

        void setEndpoint​(String endpoint)
        Sets the endpoint to call (ex, https://www.example.com).
        Parameters:
        endpoint - The endpoint of the serice.

      • getEndpoint

        String getEndpoint()
        Gets the set endpoint for REST call (ex, https://www.example.com)

      • setRegion

        void setRegion​(Region region)
        Sets the region to call (ex, Region.US_PHOENIX_1).

        Note, this will call setEndpoint after resolving the endpoint. If the service is not available in this region, however, an IllegalArgumentException will be raised.

        Parameters:
        region - The region of the service.

      • setRegion

        void setRegion​(String regionId)
        Sets the region to call (ex, ‘us-phoenix-1’).

        Note, this will first try to map the region ID to a known Region and call setRegion.

        If no known Region could be determined, it will create an endpoint based on the default endpoint format (Region.formatDefaultRegionEndpoint(Service, String) and then call setEndpoint.

        Parameters:
        regionId - The public region ID.

      • useRealmSpecificEndpointTemplate

        void useRealmSpecificEndpointTemplate​(boolean realmSpecificEndpointTemplateEnabled)
        Determines whether realm specific endpoint should be used or not.

        Set realmSpecificEndpointTemplateEnabled to “true” if the user wants to enable use of realm specific endpoint template, otherwise set it to “false”

        Parameters:
        realmSpecificEndpointTemplateEnabled - flag to enable the use of realm specific endpoint template

      • activateTargetDatabase

        Future<ActivateTargetDatabaseResponse> activateTargetDatabase​(ActivateTargetDatabaseRequest request,
                                                              AsyncHandler<ActivateTargetDatabaseRequest,​ActivateTargetDatabaseResponse> handler)
        Reactivates a previously deactivated Data Safe target database.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • addMaskingColumnsFromSdm

        Future<AddMaskingColumnsFromSdmResponse> addMaskingColumnsFromSdm​(AddMaskingColumnsFromSdmRequest request,
                                                                  AsyncHandler<AddMaskingColumnsFromSdmRequest,​AddMaskingColumnsFromSdmResponse> handler)
        Adds columns to the specified masking policy from the associated sensitive data model.

        It automatically pulls all the sensitive columns and their relationships from the sensitive data model and uses this information to create columns in the masking policy. It also assigns default masking formats to these columns based on the associated sensitive types.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • alertsUpdate

        Future<AlertsUpdateResponse> alertsUpdate​(AlertsUpdateRequest request,
                                          AsyncHandler<AlertsUpdateRequest,​AlertsUpdateResponse> handler)
        Updates alerts in the specified compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • applyDiscoveryJobResults

        Future<ApplyDiscoveryJobResultsResponse> applyDiscoveryJobResults​(ApplyDiscoveryJobResultsRequest request,
                                                                  AsyncHandler<ApplyDiscoveryJobResultsRequest,​ApplyDiscoveryJobResultsResponse> handler)
        Applies the results of a discovery job to the specified sensitive data model.

        Note that the plannedAction attribute of discovery results is used for processing them. You should first use PatchDiscoveryJobResults to set the plannedAction attribute of the discovery results you want to process. ApplyDiscoveryJobResults automatically reads the plannedAction attribute and updates the sensitive data model to reflect the actions you planned.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • applySdmMaskingPolicyDifference

        Future<ApplySdmMaskingPolicyDifferenceResponse> applySdmMaskingPolicyDifference​(ApplySdmMaskingPolicyDifferenceRequest request,
                                                                                AsyncHandler<ApplySdmMaskingPolicyDifferenceRequest,​ApplySdmMaskingPolicyDifferenceResponse> handler)
        Applies the difference of a SDM Masking policy difference resource to the specified masking policy.

        Note that the plannedAction attribute of difference columns is used for processing. You should first use PatchSdmMaskingPolicyDifferenceColumns to set the plannedAction attribute of the difference columns you want to process. ApplySdmMaskingPolicyDifference automatically reads the plannedAction attribute and updates the masking policy to reflect the actions you planned. If the sdmMaskingPolicydifferenceId is not passed, the latest sdmMaskingPolicydifference is used. Note that if the masking policy associated with the SdmMaskingPolicyDifference used for this operation is not associated with the original SDM anymore, this operation won’t be allowed.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • bulkCreateSensitiveTypes

        Future<BulkCreateSensitiveTypesResponse> bulkCreateSensitiveTypes​(BulkCreateSensitiveTypesRequest request,
                                                                  AsyncHandler<BulkCreateSensitiveTypesRequest,​BulkCreateSensitiveTypesResponse> handler)
        Uploads a sensitive types xml file (also called template) to create new sensitive types.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • calculateAuditVolumeAvailable

        Future<CalculateAuditVolumeAvailableResponse> calculateAuditVolumeAvailable​(CalculateAuditVolumeAvailableRequest request,
                                                                            AsyncHandler<CalculateAuditVolumeAvailableRequest,​CalculateAuditVolumeAvailableResponse> handler)
        Calculates the volume of audit events available on the target database to be collected.

        Measurable up to the defined retention period of the audit target resource.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • cancelWorkRequest

        Future<CancelWorkRequestResponse> cancelWorkRequest​(CancelWorkRequestRequest request,
                                                    AsyncHandler<CancelWorkRequestRequest,​CancelWorkRequestResponse> handler)
        Cancel the specified work request.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • changeAlertCompartment

        Future<ChangeAlertCompartmentResponse> changeAlertCompartment​(ChangeAlertCompartmentRequest request,
                                                              AsyncHandler<ChangeAlertCompartmentRequest,​ChangeAlertCompartmentResponse> handler)
        Moves the specified alert into a different compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • changeReportCompartment

        Future<ChangeReportCompartmentResponse> changeReportCompartment​(ChangeReportCompartmentRequest request,
                                                                AsyncHandler<ChangeReportCompartmentRequest,​ChangeReportCompartmentResponse> handler)
        Moves a resource into a different compartment.

        When provided, If-Match is checked against ETag values of the resource.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • changeRetention

        Future<ChangeRetentionResponse> changeRetention​(ChangeRetentionRequest request,
                                                AsyncHandler<ChangeRetentionRequest,​ChangeRetentionResponse> handler)
        Change the online and offline months .
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • changeSecurityAssessmentCompartment

        Future<ChangeSecurityAssessmentCompartmentResponse> changeSecurityAssessmentCompartment​(ChangeSecurityAssessmentCompartmentRequest request,
                                                                                        AsyncHandler<ChangeSecurityAssessmentCompartmentRequest,​ChangeSecurityAssessmentCompartmentResponse> handler)
        Moves the specified saved security assessment or future scheduled assessments into a different compartment.

        To start, call first the operation ListSecurityAssessments with filters \"type = save_schedule\". This returns the scheduleAssessmentId. Then, call this changeCompartment with the scheduleAssessmentId.

        The existing saved security assessments created due to the schedule are not moved. However, all new saves will be associated with the new compartment.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • changeUserAssessmentCompartment

        Future<ChangeUserAssessmentCompartmentResponse> changeUserAssessmentCompartment​(ChangeUserAssessmentCompartmentRequest request,
                                                                                AsyncHandler<ChangeUserAssessmentCompartmentRequest,​ChangeUserAssessmentCompartmentResponse> handler)
        Moves the specified saved user assessment or future scheduled assessments into a different compartment.

        To start storing scheduled user assessments on a different compartment, first call the operation ListUserAssessments with the filters "type = save_schedule". That call returns the scheduleAssessmentId. Then call ChangeUserAssessmentCompartment with the scheduleAssessmentId. The existing saved user assessments created per the schedule are not be moved. However, all new saves will be associated with the new compartment.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • compareSecurityAssessment

        Future<CompareSecurityAssessmentResponse> compareSecurityAssessment​(CompareSecurityAssessmentRequest request,
                                                                    AsyncHandler<CompareSecurityAssessmentRequest,​CompareSecurityAssessmentResponse> handler)
        Compares two security assessments.

        For this comparison, a security assessment can be a saved assessment, a latest assessment, or a baseline assessment. For example, you can compare saved assessment or a latest assessment against a baseline.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • compareToTemplateBaseline

        Future<CompareToTemplateBaselineResponse> compareToTemplateBaseline​(CompareToTemplateBaselineRequest request,
                                                                    AsyncHandler<CompareToTemplateBaselineRequest,​CompareToTemplateBaselineResponse> handler)
        Compares two security assessments.

        For this comparison, the security assessment in the path needs to be a latest assessment of a target group.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • compareUserAssessment

        Future<CompareUserAssessmentResponse> compareUserAssessment​(CompareUserAssessmentRequest request,
                                                            AsyncHandler<CompareUserAssessmentRequest,​CompareUserAssessmentResponse> handler)
        Compares two user assessments.

        For this comparison, a user assessment can be a saved, a latest assessment, or a baseline. As an example, it can be used to compare a user assessment saved or a latest assessment with a baseline.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createAlertPolicy

        Future<CreateAlertPolicyResponse> createAlertPolicy​(CreateAlertPolicyRequest request,
                                                    AsyncHandler<CreateAlertPolicyRequest,​CreateAlertPolicyResponse> handler)
        Creates a new user-defined alert policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createAlertPolicyRule

        Future<CreateAlertPolicyRuleResponse> createAlertPolicyRule​(CreateAlertPolicyRuleRequest request,
                                                            AsyncHandler<CreateAlertPolicyRuleRequest,​CreateAlertPolicyRuleResponse> handler)
        Creates a new rule for the alert policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createAttributeSet

        Future<CreateAttributeSetResponse> createAttributeSet​(CreateAttributeSetRequest request,
                                                      AsyncHandler<CreateAttributeSetRequest,​CreateAttributeSetResponse> handler)
        Creates an attribute set.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createAuditArchiveRetrieval

        Future<CreateAuditArchiveRetrievalResponse> createAuditArchiveRetrieval​(CreateAuditArchiveRetrievalRequest request,
                                                                        AsyncHandler<CreateAuditArchiveRetrievalRequest,​CreateAuditArchiveRetrievalResponse> handler)
        Creates a work request to retrieve archived audit data.

        This asynchronous process will usually take over an hour to complete. Save the id from the response of this operation. Call GetAuditArchiveRetrieval operation after an hour, passing the id to know the status of this operation.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createAuditProfile

        Future<CreateAuditProfileResponse> createAuditProfile​(CreateAuditProfileRequest request,
                                                      AsyncHandler<CreateAuditProfileRequest,​CreateAuditProfileResponse> handler)
        Create a new audit profile resource.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createDiscoveryJob

        Future<CreateDiscoveryJobResponse> createDiscoveryJob​(CreateDiscoveryJobRequest request,
                                                      AsyncHandler<CreateDiscoveryJobRequest,​CreateDiscoveryJobResponse> handler)
        Performs incremental data discovery for the specified sensitive data model.

        It uses the target database associated with the sensitive data model. After performing data discovery, you can use ListDiscoveryJobResults to view the discovery results, PatchDiscoveryJobResults to specify the action you want perform on these results, and then ApplyDiscoveryJobResults to process the results and apply them to the sensitive data model.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createLibraryMaskingFormat

        Future<CreateLibraryMaskingFormatResponse> createLibraryMaskingFormat​(CreateLibraryMaskingFormatRequest request,
                                                                      AsyncHandler<CreateLibraryMaskingFormatRequest,​CreateLibraryMaskingFormatResponse> handler)
        Creates a new library masking format.

        A masking format can have one or more format entries. The combined output of all the format entries is used for masking. It provides the flexibility to define a masking format that can generate different parts of a data value separately and then combine them to get the final data value for masking. Note that you cannot define masking condition in a library masking format.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createMaskingColumn

        Future<CreateMaskingColumnResponse> createMaskingColumn​(CreateMaskingColumnRequest request,
                                                        AsyncHandler<CreateMaskingColumnRequest,​CreateMaskingColumnResponse> handler)
        Creates a new masking column in the specified masking policy.

        Use this operation to add parent columns only. It automatically adds the child columns from the associated sensitive data model or target database. If you provide the sensitiveTypeId attribute but not the maskingFormats attribute, it automatically assigns the default masking format associated with the specified sensitive type. Alternatively, if you provide the maskingFormats attribute, the specified masking formats are assigned to the column.

        Using the maskingFormats attribute, you can assign one or more masking formats to a column. You need to specify a condition as part of each masking format. It enables you to do conditional masking so that you can mask the column data values differently using different masking conditions. A masking format can have one or more format entries. The combined output of all the format entries is used for masking. It provides the flexibility to define a masking format that can generate different parts of a data value separately and then combine them to get the final data value for masking.

        You can use the maskingColumnGroup attribute to group the columns that you would like to mask together. It enables you to do group or compound masking that ensures that the masked data across the columns in a group continue to retain the same logical relationship.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createMaskingPolicy

        Future<CreateMaskingPolicyResponse> createMaskingPolicy​(CreateMaskingPolicyRequest request,
                                                        AsyncHandler<CreateMaskingPolicyRequest,​CreateMaskingPolicyResponse> handler)
        Creates a new masking policy and associates it with a sensitive data model or a target database.

        To use a sensitive data model as the source of masking columns, set the columnSource attribute to SENSITIVE_DATA_MODEL and provide the sensitiveDataModelId attribute. After creating a masking policy, you can use the AddMaskingColumnsFromSdm operation to automatically add all the columns from the associated sensitive data model. In this case, the target database associated with the sensitive data model is used for column and masking format validations.

        You can also create a masking policy without using a sensitive data model. In this case, you need to associate your masking policy with a target database by setting the columnSource attribute to TARGET and providing the targetId attribute. The specified target database is used for column and masking format validations.

        After creating a masking policy, you can use the CreateMaskingColumn or PatchMaskingColumns operation to manually add columns to the policy. You need to add the parent columns only, and it automatically adds the child columns (in referential relationship with the parent columns) from the associated sensitive data model or target database.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createOnPremConnector

        Future<CreateOnPremConnectorResponse> createOnPremConnector​(CreateOnPremConnectorRequest request,
                                                            AsyncHandler<CreateOnPremConnectorRequest,​CreateOnPremConnectorResponse> handler)
        Creates a new on-premises connector.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createPeerTargetDatabase

        Future<CreatePeerTargetDatabaseResponse> createPeerTargetDatabase​(CreatePeerTargetDatabaseRequest request,
                                                                  AsyncHandler<CreatePeerTargetDatabaseRequest,​CreatePeerTargetDatabaseResponse> handler)
        Creates the peer target database under the primary target database in Data Safe.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createReferentialRelation

        Future<CreateReferentialRelationResponse> createReferentialRelation​(CreateReferentialRelationRequest request,
                                                                    AsyncHandler<CreateReferentialRelationRequest,​CreateReferentialRelationResponse> handler)
        Creates a new referential relation in the specified sensitive data model.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createReportDefinition

        Future<CreateReportDefinitionResponse> createReportDefinition​(CreateReportDefinitionRequest request,
                                                              AsyncHandler<CreateReportDefinitionRequest,​CreateReportDefinitionResponse> handler)
        Creates a new report definition with parameters specified in the body.

        The report definition is stored in the specified compartment.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createSdmMaskingPolicyDifference

        Future<CreateSdmMaskingPolicyDifferenceResponse> createSdmMaskingPolicyDifference​(CreateSdmMaskingPolicyDifferenceRequest request,
                                                                                  AsyncHandler<CreateSdmMaskingPolicyDifferenceRequest,​CreateSdmMaskingPolicyDifferenceResponse> handler)
        Creates SDM masking policy difference for the specified masking policy.

        It finds the difference between masking columns of the masking policy and sensitive columns of the SDM. After performing this operation, you can use ListDifferenceColumns to view the difference columns, PatchSdmMaskingPolicyDifferenceColumns to specify the action you want perform on these columns, and then ApplySdmMaskingPolicyDifference to process the difference columns and apply them to the masking policy.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createSecurityAssessment

        Future<CreateSecurityAssessmentResponse> createSecurityAssessment​(CreateSecurityAssessmentRequest request,
                                                                  AsyncHandler<CreateSecurityAssessmentRequest,​CreateSecurityAssessmentResponse> handler)
        Creates a new saved security assessment for one or multiple targets in a compartment.

        When this operation is performed, it will save the latest assessments in the specified compartment. If a schedule is passed, it will persist the latest assessments, at the defined date and time, in the format defined by RFC3339.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createSecurityPolicy

        Future<CreateSecurityPolicyResponse> createSecurityPolicy​(CreateSecurityPolicyRequest request,
                                                          AsyncHandler<CreateSecurityPolicyRequest,​CreateSecurityPolicyResponse> handler)
        Creates a Data Safe security policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createSensitiveColumn

        Future<CreateSensitiveColumnResponse> createSensitiveColumn​(CreateSensitiveColumnRequest request,
                                                            AsyncHandler<CreateSensitiveColumnRequest,​CreateSensitiveColumnResponse> handler)
        Creates a new sensitive column in the specified sensitive data model.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createSensitiveDataModel

        Future<CreateSensitiveDataModelResponse> createSensitiveDataModel​(CreateSensitiveDataModelRequest request,
                                                                  AsyncHandler<CreateSensitiveDataModelRequest,​CreateSensitiveDataModelResponse> handler)
        Creates a new sensitive data model.

        If schemas and sensitive types are provided, it automatically runs data discovery and adds the discovered columns to the sensitive data model. Otherwise, it creates an empty sensitive data model that can be updated later.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createSensitiveType

        Future<CreateSensitiveTypeResponse> createSensitiveType​(CreateSensitiveTypeRequest request,
                                                        AsyncHandler<CreateSensitiveTypeRequest,​CreateSensitiveTypeResponse> handler)
        Creates a new sensitive type, which can be a basic sensitive type with regular expressions or a sensitive category.

        While sensitive types are used for data discovery, sensitive categories are used for logically grouping the related or similar sensitive types.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createSensitiveTypesExport

        Future<CreateSensitiveTypesExportResponse> createSensitiveTypesExport​(CreateSensitiveTypesExportRequest request,
                                                                      AsyncHandler<CreateSensitiveTypesExportRequest,​CreateSensitiveTypesExportResponse> handler)
        Generates a downloadable file corresponding to the specified list of sensitive types.

        It’s a prerequisite for the DownloadSensitiveTypesExport operation. Use this endpoint to generate a sensitive Types Export file and then use DownloadSensitiveTypesExport to download the generated file.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createSqlCollection

        Future<CreateSqlCollectionResponse> createSqlCollection​(CreateSqlCollectionRequest request,
                                                        AsyncHandler<CreateSqlCollectionRequest,​CreateSqlCollectionResponse> handler)
        Creates a new SQL collection resource.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createTargetDatabase

        Future<CreateTargetDatabaseResponse> createTargetDatabase​(CreateTargetDatabaseRequest request,
                                                          AsyncHandler<CreateTargetDatabaseRequest,​CreateTargetDatabaseResponse> handler)
        Registers the specified database with Data Safe and creates a Data Safe target database in the Data Safe Console.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createUserAssessment

        Future<CreateUserAssessmentResponse> createUserAssessment​(CreateUserAssessmentRequest request,
                                                          AsyncHandler<CreateUserAssessmentRequest,​CreateUserAssessmentResponse> handler)
        Creates a new saved user assessment for one or multiple targets in a compartment.

        It saves the latest assessments in the specified compartment. If a scheduled is passed in, this operation persists the latest assessments that exist at the defined date and time, in the format defined by RFC3339.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteAlertPolicy

        Future<DeleteAlertPolicyResponse> deleteAlertPolicy​(DeleteAlertPolicyRequest request,
                                                    AsyncHandler<DeleteAlertPolicyRequest,​DeleteAlertPolicyResponse> handler)
        Deletes the specified user-defined alert policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteAlertPolicyRule

        Future<DeleteAlertPolicyRuleResponse> deleteAlertPolicyRule​(DeleteAlertPolicyRuleRequest request,
                                                            AsyncHandler<DeleteAlertPolicyRuleRequest,​DeleteAlertPolicyRuleResponse> handler)
        Deletes the specified user-defined alert policy rule.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteAttributeSet

        Future<DeleteAttributeSetResponse> deleteAttributeSet​(DeleteAttributeSetRequest request,
                                                      AsyncHandler<DeleteAttributeSetRequest,​DeleteAttributeSetResponse> handler)
        Submits a work request to delete an attribute set.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteAuditArchiveRetrieval

        Future<DeleteAuditArchiveRetrievalResponse> deleteAuditArchiveRetrieval​(DeleteAuditArchiveRetrievalRequest request,
                                                                        AsyncHandler<DeleteAuditArchiveRetrievalRequest,​DeleteAuditArchiveRetrievalResponse> handler)
        To unload retrieved archive data, call the operation ListAuditArchiveRetrieval first.

        This will return the auditArchiveRetrievalId. Then call this operation with auditArchiveRetrievalId.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteAuditProfile

        Future<DeleteAuditProfileResponse> deleteAuditProfile​(DeleteAuditProfileRequest request,
                                                      AsyncHandler<DeleteAuditProfileRequest,​DeleteAuditProfileResponse> handler)
        Deletes the specified audit profile.

        The audit profile delete operation is only supported for audit profiles with target type as TARGET_DATABASE_GROUP.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteAuditTrail

        Future<DeleteAuditTrailResponse> deleteAuditTrail​(DeleteAuditTrailRequest request,
                                                  AsyncHandler<DeleteAuditTrailRequest,​DeleteAuditTrailResponse> handler)
        Deletes the specified audit trail.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteDiscoveryJob

        Future<DeleteDiscoveryJobResponse> deleteDiscoveryJob​(DeleteDiscoveryJobRequest request,
                                                      AsyncHandler<DeleteDiscoveryJobRequest,​DeleteDiscoveryJobResponse> handler)
        Deletes the specified discovery job.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteMaskingColumn

        Future<DeleteMaskingColumnResponse> deleteMaskingColumn​(DeleteMaskingColumnRequest request,
                                                        AsyncHandler<DeleteMaskingColumnRequest,​DeleteMaskingColumnResponse> handler)
        Deletes the specified masking column.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteMaskingPolicy

        Future<DeleteMaskingPolicyResponse> deleteMaskingPolicy​(DeleteMaskingPolicyRequest request,
                                                        AsyncHandler<DeleteMaskingPolicyRequest,​DeleteMaskingPolicyResponse> handler)
        Deletes the specified masking policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteMaskingReport

        Future<DeleteMaskingReportResponse> deleteMaskingReport​(DeleteMaskingReportRequest request,
                                                        AsyncHandler<DeleteMaskingReportRequest,​DeleteMaskingReportResponse> handler)
        Deletes the specified masking report.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteOnPremConnector

        Future<DeleteOnPremConnectorResponse> deleteOnPremConnector​(DeleteOnPremConnectorRequest request,
                                                            AsyncHandler<DeleteOnPremConnectorRequest,​DeleteOnPremConnectorResponse> handler)
        Deletes the specified on-premises connector.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deletePeerTargetDatabase

        Future<DeletePeerTargetDatabaseResponse> deletePeerTargetDatabase​(DeletePeerTargetDatabaseRequest request,
                                                                  AsyncHandler<DeletePeerTargetDatabaseRequest,​DeletePeerTargetDatabaseResponse> handler)
        Removes the specified peer target database from Data Safe.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteReportDefinition

        Future<DeleteReportDefinitionResponse> deleteReportDefinition​(DeleteReportDefinitionRequest request,
                                                              AsyncHandler<DeleteReportDefinitionRequest,​DeleteReportDefinitionResponse> handler)
        Deletes the specified report definition.

        Only the user created report definition can be deleted. The seeded report definitions cannot be deleted.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteSecurityAssessment

        Future<DeleteSecurityAssessmentResponse> deleteSecurityAssessment​(DeleteSecurityAssessmentRequest request,
                                                                  AsyncHandler<DeleteSecurityAssessmentRequest,​DeleteSecurityAssessmentResponse> handler)
        Deletes the specified saved security assessment or schedule.

        To delete a security assessment schedule, first call the operation ListSecurityAssessments with filters "type = save_schedule". That operation returns the scheduleAssessmentId. Then, call DeleteSecurityAssessment with the scheduleAssessmentId. If the assessment being deleted is the baseline for that compartment, then it will impact all baselines in the compartment.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteSecurityPolicy

        Future<DeleteSecurityPolicyResponse> deleteSecurityPolicy​(DeleteSecurityPolicyRequest request,
                                                          AsyncHandler<DeleteSecurityPolicyRequest,​DeleteSecurityPolicyResponse> handler)
        Deletes the specified security policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteSensitiveColumn

        Future<DeleteSensitiveColumnResponse> deleteSensitiveColumn​(DeleteSensitiveColumnRequest request,
                                                            AsyncHandler<DeleteSensitiveColumnRequest,​DeleteSensitiveColumnResponse> handler)
        Deletes the specified sensitive column.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteSensitiveType

        Future<DeleteSensitiveTypeResponse> deleteSensitiveType​(DeleteSensitiveTypeRequest request,
                                                        AsyncHandler<DeleteSensitiveTypeRequest,​DeleteSensitiveTypeResponse> handler)
        Deletes the specified sensitive type.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteSqlCollection

        Future<DeleteSqlCollectionResponse> deleteSqlCollection​(DeleteSqlCollectionRequest request,
                                                        AsyncHandler<DeleteSqlCollectionRequest,​DeleteSqlCollectionResponse> handler)
        Deletes the specified SQL collection.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteTargetDatabase

        Future<DeleteTargetDatabaseResponse> deleteTargetDatabase​(DeleteTargetDatabaseRequest request,
                                                          AsyncHandler<DeleteTargetDatabaseRequest,​DeleteTargetDatabaseResponse> handler)
        Deregisters the specified database from Data Safe and removes the target database from the Data Safe Console.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteUserAssessment

        Future<DeleteUserAssessmentResponse> deleteUserAssessment​(DeleteUserAssessmentRequest request,
                                                          AsyncHandler<DeleteUserAssessmentRequest,​DeleteUserAssessmentResponse> handler)
        Deletes the specified saved user assessment or schedule.

        To delete a user assessment schedule, first call the operation ListUserAssessments with filters "type = save_schedule". That call returns the scheduleAssessmentId. Then call DeleteUserAssessment with the scheduleAssessmentId. If the assessment being deleted is the baseline for that compartment, then it will impact all baselines in the compartment.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • discoverAuditTrails

        Future<DiscoverAuditTrailsResponse> discoverAuditTrails​(DiscoverAuditTrailsRequest request,
                                                        AsyncHandler<DiscoverAuditTrailsRequest,​DiscoverAuditTrailsResponse> handler)
        Updates the list of audit trails created under audit profile.The operation can be used to create new audit trails for target database when they become available for audit collection because of change of database version or change of database unified mode or change of data base edition or being deleted previously etc.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • downloadDiscoveryReport

        Future<DownloadDiscoveryReportResponse> downloadDiscoveryReport​(DownloadDiscoveryReportRequest request,
                                                                AsyncHandler<DownloadDiscoveryReportRequest,​DownloadDiscoveryReportResponse> handler)
        Downloads an already-generated discovery report.

        Note that the GenerateDiscoveryReportForDownload operation is a prerequisite for the DownloadDiscoveryReport operation. Use GenerateDiscoveryReportForDownload to generate a discovery report file and then use DownloadDiscoveryReport to download the generated file. By default, it downloads report for all the columns in a sensitive data model. Use the discoveryJobId attribute to download report for a specific discovery job.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • downloadMaskingLog

        Future<DownloadMaskingLogResponse> downloadMaskingLog​(DownloadMaskingLogRequest request,
                                                      AsyncHandler<DownloadMaskingLogRequest,​DownloadMaskingLogResponse> handler)
        Downloads the masking log generated by the last masking operation on a target database using the specified masking policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • downloadMaskingPolicy

        Future<DownloadMaskingPolicyResponse> downloadMaskingPolicy​(DownloadMaskingPolicyRequest request,
                                                            AsyncHandler<DownloadMaskingPolicyRequest,​DownloadMaskingPolicyResponse> handler)
        Downloads an already-generated file corresponding to the specified masking policy.

        Note that the GenerateMaskingPolicyForDownload operation is a prerequisite for the DownloadMaskingPolicy operation. Use GenerateMaskingPolicyForDownload to generate a masking policy file and then use DownloadMaskingPolicy to download the generated file.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • downloadMaskingReport

        Future<DownloadMaskingReportResponse> downloadMaskingReport​(DownloadMaskingReportRequest request,
                                                            AsyncHandler<DownloadMaskingReportRequest,​DownloadMaskingReportResponse> handler)
        Downloads an already-generated masking report.

        Note that the GenerateMaskingReportForDownload operation is a prerequisite for the DownloadMaskingReport operation. Use GenerateMaskingReportForDownload to generate a masking report file and then use DownloadMaskingReport to download the generated file.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • downloadPrivilegeScript

        Future<DownloadPrivilegeScriptResponse> downloadPrivilegeScript​(DownloadPrivilegeScriptRequest request,
                                                                AsyncHandler<DownloadPrivilegeScriptRequest,​DownloadPrivilegeScriptResponse> handler)
        Downloads the privilege script to grant/revoke required roles from the Data Safe account on the target database.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • downloadSecurityAssessmentReport

        Future<DownloadSecurityAssessmentReportResponse> downloadSecurityAssessmentReport​(DownloadSecurityAssessmentReportRequest request,
                                                                                  AsyncHandler<DownloadSecurityAssessmentReportRequest,​DownloadSecurityAssessmentReportResponse> handler)
        Downloads the report of the specified security assessment.

        To download the security assessment report, it needs to be generated first. Please use GenerateSecurityAssessmentReport to generate a downloadable report in the preferred format (PDF, XLS).

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • downloadSensitiveDataModel

        Future<DownloadSensitiveDataModelResponse> downloadSensitiveDataModel​(DownloadSensitiveDataModelRequest request,
                                                                      AsyncHandler<DownloadSensitiveDataModelRequest,​DownloadSensitiveDataModelResponse> handler)
        Downloads an already-generated file corresponding to the specified sensitive data model.

        Note that the GenerateSensitiveDataModelForDownload operation is a prerequisite for the DownloadSensitiveDataModel operation. Use GenerateSensitiveDataModelForDownload to generate a data model file and then use DownloadSensitiveDataModel to download the generated file.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • downloadSensitiveTypesExport

        Future<DownloadSensitiveTypesExportResponse> downloadSensitiveTypesExport​(DownloadSensitiveTypesExportRequest request,
                                                                          AsyncHandler<DownloadSensitiveTypesExportRequest,​DownloadSensitiveTypesExportResponse> handler)
        Downloads an already-generated file corresponding to the specified sensitive types export.

        Use CreateSensitiveTypesExport to generate an XML file and then use DownloadSensitiveTypesExport to download the generated file.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • downloadUserAssessmentReport

        Future<DownloadUserAssessmentReportResponse> downloadUserAssessmentReport​(DownloadUserAssessmentReportRequest request,
                                                                          AsyncHandler<DownloadUserAssessmentReportRequest,​DownloadUserAssessmentReportResponse> handler)
        Downloads the report of the specified user assessment.

        To download the user assessment report, it needs to be generated first. Please use GenerateUserAssessmentReport to generate a downloadable report in the preferred format (PDF, XLS).

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • generateDiscoveryReportForDownload

        Future<GenerateDiscoveryReportForDownloadResponse> generateDiscoveryReportForDownload​(GenerateDiscoveryReportForDownloadRequest request,
                                                                                      AsyncHandler<GenerateDiscoveryReportForDownloadRequest,​GenerateDiscoveryReportForDownloadResponse> handler)
        Generates a downloadable discovery report.

        It’s a prerequisite for the DownloadDiscoveryReport operation. Use this endpoint to generate a discovery report file and then use DownloadDiscoveryReport to download the generated file. By default, it generates report for all the columns in a sensitive data model. Use the discoveryJobId attribute to generate report for a specific discovery job.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • generateHealthReport

        Future<GenerateHealthReportResponse> generateHealthReport​(GenerateHealthReportRequest request,
                                                          AsyncHandler<GenerateHealthReportRequest,​GenerateHealthReportResponse> handler)
        Performs health check on the masking policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • generateMaskingPolicyForDownload

        Future<GenerateMaskingPolicyForDownloadResponse> generateMaskingPolicyForDownload​(GenerateMaskingPolicyForDownloadRequest request,
                                                                                  AsyncHandler<GenerateMaskingPolicyForDownloadRequest,​GenerateMaskingPolicyForDownloadResponse> handler)
        Generates a downloadable file corresponding to the specified masking policy.

        It’s a prerequisite for the DownloadMaskingPolicy operation. Use this endpoint to generate a masking policy file and then use DownloadMaskingPolicy to download the generated file. Note that file generation and download are serial operations. The download operation can’t be invoked while the generate operation is in progress.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • generateMaskingReportForDownload

        Future<GenerateMaskingReportForDownloadResponse> generateMaskingReportForDownload​(GenerateMaskingReportForDownloadRequest request,
                                                                                  AsyncHandler<GenerateMaskingReportForDownloadRequest,​GenerateMaskingReportForDownloadResponse> handler)
        Generates a downloadable masking report.

        It’s a prerequisite for the DownloadMaskingReport operation. Use this endpoint to generate a masking report file and then use DownloadMaskingReport to download the generated file.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • generateReport

        Future<GenerateReportResponse> generateReport​(GenerateReportRequest request,
                                              AsyncHandler<GenerateReportRequest,​GenerateReportResponse> handler)
        Generates a .xls or .pdf report based on parameters and report definition.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • generateSecurityAssessmentReport

        Future<GenerateSecurityAssessmentReportResponse> generateSecurityAssessmentReport​(GenerateSecurityAssessmentReportRequest request,
                                                                                  AsyncHandler<GenerateSecurityAssessmentReportRequest,​GenerateSecurityAssessmentReportResponse> handler)
        Generates the report of the specified security assessment.

        You can get the report in PDF or XLS format. After generating the report, use DownloadSecurityAssessmentReport to download it in the preferred format.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • generateSensitiveDataModelForDownload

        Future<GenerateSensitiveDataModelForDownloadResponse> generateSensitiveDataModelForDownload​(GenerateSensitiveDataModelForDownloadRequest request,
                                                                                            AsyncHandler<GenerateSensitiveDataModelForDownloadRequest,​GenerateSensitiveDataModelForDownloadResponse> handler)
        Generates a downloadable file corresponding to the specified sensitive data model.

        It’s a prerequisite for the DownloadSensitiveDataModel operation. Use this endpoint to generate a data model file and then use DownloadSensitiveDataModel to download the generated file. Note that file generation and download are serial operations. The download operation can’t be invoked while the generate operation is in progress.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • generateSqlFirewallPolicy

        Future<GenerateSqlFirewallPolicyResponse> generateSqlFirewallPolicy​(GenerateSqlFirewallPolicyRequest request,
                                                                    AsyncHandler<GenerateSqlFirewallPolicyRequest,​GenerateSqlFirewallPolicyResponse> handler)
        Generates or appends to the SQL Firewall policy using the specified SQL collection.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • generateUserAssessmentReport

        Future<GenerateUserAssessmentReportResponse> generateUserAssessmentReport​(GenerateUserAssessmentReportRequest request,
                                                                          AsyncHandler<GenerateUserAssessmentReportRequest,​GenerateUserAssessmentReportResponse> handler)
        Generates the report of the specified user assessment.

        The report is available in PDF or XLS format. After generating the report, use DownloadUserAssessmentReport to download it in the preferred format.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getAlert

        Future<GetAlertResponse> getAlert​(GetAlertRequest request,
                                  AsyncHandler<GetAlertRequest,​GetAlertResponse> handler)
        Gets the details of the specified alerts.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getAlertPolicy

        Future<GetAlertPolicyResponse> getAlertPolicy​(GetAlertPolicyRequest request,
                                              AsyncHandler<GetAlertPolicyRequest,​GetAlertPolicyResponse> handler)
        Gets the details of alert policy by its ID.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getAlertPolicyRule

        Future<GetAlertPolicyRuleResponse> getAlertPolicyRule​(GetAlertPolicyRuleRequest request,
                                                      AsyncHandler<GetAlertPolicyRuleRequest,​GetAlertPolicyRuleResponse> handler)
        Gets the details of a policy rule by its key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getAttributeSet

        Future<GetAttributeSetResponse> getAttributeSet​(GetAttributeSetRequest request,
                                                AsyncHandler<GetAttributeSetRequest,​GetAttributeSetResponse> handler)
        Gets the details of the specified attribute set.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getAuditPolicy

        Future<GetAuditPolicyResponse> getAuditPolicy​(GetAuditPolicyRequest request,
                                              AsyncHandler<GetAuditPolicyRequest,​GetAuditPolicyResponse> handler)
        Gets a audit policy by identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getAuditProfile

        Future<GetAuditProfileResponse> getAuditProfile​(GetAuditProfileRequest request,
                                                AsyncHandler<GetAuditProfileRequest,​GetAuditProfileResponse> handler)
        Gets the details of audit profile resource and associated audit trails of the audit profile.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getAuditTrail

        Future<GetAuditTrailResponse> getAuditTrail​(GetAuditTrailRequest request,
                                            AsyncHandler<GetAuditTrailRequest,​GetAuditTrailResponse> handler)
        Gets the details of audit trail.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getCompatibleFormatsForDataTypes

        Future<GetCompatibleFormatsForDataTypesResponse> getCompatibleFormatsForDataTypes​(GetCompatibleFormatsForDataTypesRequest request,
                                                                                  AsyncHandler<GetCompatibleFormatsForDataTypesRequest,​GetCompatibleFormatsForDataTypesResponse> handler)
        Gets a list of basic masking formats compatible with the supported data types.

        The data types are grouped into the following categories - Character - Includes CHAR, NCHAR, VARCHAR2, and NVARCHAR2 Numeric - Includes NUMBER, FLOAT, RAW, BINARY_FLOAT, and BINARY_DOUBLE Date - Includes DATE and TIMESTAMP LOB - Includes BLOB, CLOB, and NCLOB All - Includes all the supported data types

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getCompatibleFormatsForSensitiveTypes

        Future<GetCompatibleFormatsForSensitiveTypesResponse> getCompatibleFormatsForSensitiveTypes​(GetCompatibleFormatsForSensitiveTypesRequest request,
                                                                                            AsyncHandler<GetCompatibleFormatsForSensitiveTypesRequest,​GetCompatibleFormatsForSensitiveTypesResponse> handler)
        Gets a list of library masking formats compatible with the existing sensitive types.

        For each sensitive type, it returns the assigned default masking format as well as the other library masking formats that have the sensitiveTypeIds attribute containing the OCID of the sensitive type.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getDifferenceColumn

        Future<GetDifferenceColumnResponse> getDifferenceColumn​(GetDifferenceColumnRequest request,
                                                        AsyncHandler<GetDifferenceColumnRequest,​GetDifferenceColumnResponse> handler)
        Gets the details of the specified SDM Masking policy difference column.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getDiscoveryJob

        Future<GetDiscoveryJobResponse> getDiscoveryJob​(GetDiscoveryJobRequest request,
                                                AsyncHandler<GetDiscoveryJobRequest,​GetDiscoveryJobResponse> handler)
        Gets the details of the specified discovery job.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getDiscoveryJobResult

        Future<GetDiscoveryJobResultResponse> getDiscoveryJobResult​(GetDiscoveryJobResultRequest request,
                                                            AsyncHandler<GetDiscoveryJobResultRequest,​GetDiscoveryJobResultResponse> handler)
        Gets the details of the specified discovery result.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getGroupMembers

        Future<GetGroupMembersResponse> getGroupMembers​(GetGroupMembersRequest request,
                                                AsyncHandler<GetGroupMembersRequest,​GetGroupMembersResponse> handler)
        Retrieves the members of the target database group with the specified OCID.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getLibraryMaskingFormat

        Future<GetLibraryMaskingFormatResponse> getLibraryMaskingFormat​(GetLibraryMaskingFormatRequest request,
                                                                AsyncHandler<GetLibraryMaskingFormatRequest,​GetLibraryMaskingFormatResponse> handler)
        Gets the details of the specified library masking format.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getMaskingColumn

        Future<GetMaskingColumnResponse> getMaskingColumn​(GetMaskingColumnRequest request,
                                                  AsyncHandler<GetMaskingColumnRequest,​GetMaskingColumnResponse> handler)
        Gets the details of the specified masking column.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getMaskingPolicy

        Future<GetMaskingPolicyResponse> getMaskingPolicy​(GetMaskingPolicyRequest request,
                                                  AsyncHandler<GetMaskingPolicyRequest,​GetMaskingPolicyResponse> handler)
        Gets the details of the specified masking policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getMaskingReport

        Future<GetMaskingReportResponse> getMaskingReport​(GetMaskingReportRequest request,
                                                  AsyncHandler<GetMaskingReportRequest,​GetMaskingReportResponse> handler)
        Gets the details of the specified masking report.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getOnPremConnector

        Future<GetOnPremConnectorResponse> getOnPremConnector​(GetOnPremConnectorRequest request,
                                                      AsyncHandler<GetOnPremConnectorRequest,​GetOnPremConnectorResponse> handler)
        Gets the details of the specified on-premises connector.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getPeerTargetDatabase

        Future<GetPeerTargetDatabaseResponse> getPeerTargetDatabase​(GetPeerTargetDatabaseRequest request,
                                                            AsyncHandler<GetPeerTargetDatabaseRequest,​GetPeerTargetDatabaseResponse> handler)
        Returns the details of the specified Data Safe peer target database.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getProfile

        Future<GetProfileResponse> getProfile​(GetProfileRequest request,
                                      AsyncHandler<GetProfileRequest,​GetProfileResponse> handler)
        Lists the details of given profile available on the target.

        The GetProfile operation returns only the profiles in the specified 'userAssessmentId'. This does not include any subcompartments of the current compartment.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getReferentialRelation

        Future<GetReferentialRelationResponse> getReferentialRelation​(GetReferentialRelationRequest request,
                                                              AsyncHandler<GetReferentialRelationRequest,​GetReferentialRelationResponse> handler)
        Gets the details of the specified referential relation.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getReport

        Future<GetReportResponse> getReport​(GetReportRequest request,
                                    AsyncHandler<GetReportRequest,​GetReportResponse> handler)
        Gets a report by identifier
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getReportContent

        Future<GetReportContentResponse> getReportContent​(GetReportContentRequest request,
                                                  AsyncHandler<GetReportContentRequest,​GetReportContentResponse> handler)
        Downloads the specified report in the form of .xls or .pdf.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getReportDefinition

        Future<GetReportDefinitionResponse> getReportDefinition​(GetReportDefinitionRequest request,
                                                        AsyncHandler<GetReportDefinitionRequest,​GetReportDefinitionResponse> handler)
        Gets the details of report definition specified by the identifier
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getSecurityAssessment

        Future<GetSecurityAssessmentResponse> getSecurityAssessment​(GetSecurityAssessmentRequest request,
                                                            AsyncHandler<GetSecurityAssessmentRequest,​GetSecurityAssessmentResponse> handler)
        Gets the details of the specified security assessment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getSecurityPolicy

        Future<GetSecurityPolicyResponse> getSecurityPolicy​(GetSecurityPolicyRequest request,
                                                    AsyncHandler<GetSecurityPolicyRequest,​GetSecurityPolicyResponse> handler)
        Gets a security policy by the specified OCID of the security policy resource.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getSecurityPolicyConfig

        Future<GetSecurityPolicyConfigResponse> getSecurityPolicyConfig​(GetSecurityPolicyConfigRequest request,
                                                                AsyncHandler<GetSecurityPolicyConfigRequest,​GetSecurityPolicyConfigResponse> handler)
        Gets a security policy configuration by identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getSecurityPolicyReport

        Future<GetSecurityPolicyReportResponse> getSecurityPolicyReport​(GetSecurityPolicyReportRequest request,
                                                                AsyncHandler<GetSecurityPolicyReportRequest,​GetSecurityPolicyReportResponse> handler)
        Gets a security policy report by the specified OCID of the security policy report resource.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getSensitiveColumn

        Future<GetSensitiveColumnResponse> getSensitiveColumn​(GetSensitiveColumnRequest request,
                                                      AsyncHandler<GetSensitiveColumnRequest,​GetSensitiveColumnResponse> handler)
        Gets the details of the specified sensitive column.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getSensitiveDataModel

        Future<GetSensitiveDataModelResponse> getSensitiveDataModel​(GetSensitiveDataModelRequest request,
                                                            AsyncHandler<GetSensitiveDataModelRequest,​GetSensitiveDataModelResponse> handler)
        Gets the details of the specified sensitive data model.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getSensitiveType

        Future<GetSensitiveTypeResponse> getSensitiveType​(GetSensitiveTypeRequest request,
                                                  AsyncHandler<GetSensitiveTypeRequest,​GetSensitiveTypeResponse> handler)
        Gets the details of the specified sensitive type.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getSensitiveTypeGroup

        Future<GetSensitiveTypeGroupResponse> getSensitiveTypeGroup​(GetSensitiveTypeGroupRequest request,
                                                            AsyncHandler<GetSensitiveTypeGroupRequest,​GetSensitiveTypeGroupResponse> handler)
        Gets the details of the specified sensitive type group.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getSensitiveTypesExport

        Future<GetSensitiveTypesExportResponse> getSensitiveTypesExport​(GetSensitiveTypesExportRequest request,
                                                                AsyncHandler<GetSensitiveTypesExportRequest,​GetSensitiveTypesExportResponse> handler)
        Gets the details of the specified sensitive types export by identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getSqlCollection

        Future<GetSqlCollectionResponse> getSqlCollection​(GetSqlCollectionRequest request,
                                                  AsyncHandler<GetSqlCollectionRequest,​GetSqlCollectionResponse> handler)
        Gets a SQL collection by identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getSqlFirewallPolicy

        Future<GetSqlFirewallPolicyResponse> getSqlFirewallPolicy​(GetSqlFirewallPolicyRequest request,
                                                          AsyncHandler<GetSqlFirewallPolicyRequest,​GetSqlFirewallPolicyResponse> handler)
        Gets a SQL Firewall policy by identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getTargetDatabase

        Future<GetTargetDatabaseResponse> getTargetDatabase​(GetTargetDatabaseRequest request,
                                                    AsyncHandler<GetTargetDatabaseRequest,​GetTargetDatabaseResponse> handler)
        Returns the details of the specified Data Safe target database.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getTargetDatabaseGroup

        Future<GetTargetDatabaseGroupResponse> getTargetDatabaseGroup​(GetTargetDatabaseGroupRequest request,
                                                              AsyncHandler<GetTargetDatabaseGroupRequest,​GetTargetDatabaseGroupResponse> handler)
        Returns the details of the specified target database group.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getUnifiedAuditPolicy

        Future<GetUnifiedAuditPolicyResponse> getUnifiedAuditPolicy​(GetUnifiedAuditPolicyRequest request,
                                                            AsyncHandler<GetUnifiedAuditPolicyRequest,​GetUnifiedAuditPolicyResponse> handler)
        Gets a Unified Audit policy by identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getUserAssessment

        Future<GetUserAssessmentResponse> getUserAssessment​(GetUserAssessmentRequest request,
                                                    AsyncHandler<GetUserAssessmentRequest,​GetUserAssessmentResponse> handler)
        Gets a user assessment by identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getWorkRequest

        Future<GetWorkRequestResponse> getWorkRequest​(GetWorkRequestRequest request,
                                              AsyncHandler<GetWorkRequestRequest,​GetWorkRequestResponse> handler)
        Gets the details of the specified work request.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listAlertAnalytics

        Future<ListAlertAnalyticsResponse> listAlertAnalytics​(ListAlertAnalyticsRequest request,
                                                      AsyncHandler<ListAlertAnalyticsRequest,​ListAlertAnalyticsResponse> handler)
        Returns the aggregation details of the alerts.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listAlertPolicies

        Future<ListAlertPoliciesResponse> listAlertPolicies​(ListAlertPoliciesRequest request,
                                                    AsyncHandler<ListAlertPoliciesRequest,​ListAlertPoliciesResponse> handler)
        Gets a list of all alert policies.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listAlertPolicyRules

        Future<ListAlertPolicyRulesResponse> listAlertPolicyRules​(ListAlertPolicyRulesRequest request,
                                                          AsyncHandler<ListAlertPolicyRulesRequest,​ListAlertPolicyRulesResponse> handler)
        Lists the rules of the specified alert policy.

        The alert policy is said to be satisfied when all rules in the policy evaulate to true. If there are three rules: rule1,rule2 and rule3, the policy is satisfied if rule1 AND rule2 AND rule3 is True.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listAlerts

        Future<ListAlertsResponse> listAlerts​(ListAlertsRequest request,
                                      AsyncHandler<ListAlertsRequest,​ListAlertsResponse> handler)
        Gets a list of all alerts.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listAttributeSets

        Future<ListAttributeSetsResponse> listAttributeSets​(ListAttributeSetsRequest request,
                                                    AsyncHandler<ListAttributeSetsRequest,​ListAttributeSetsResponse> handler)
        Retrieves the list of attribute sets.

        The ListAttributeSets operation returns only the attribute sets in the specified `compartmentId`.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requester has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListAttributeSet on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listAuditEventAnalytics

        Future<ListAuditEventAnalyticsResponse> listAuditEventAnalytics​(ListAuditEventAnalyticsRequest request,
                                                                AsyncHandler<ListAuditEventAnalyticsRequest,​ListAuditEventAnalyticsResponse> handler)
        By default the ListAuditEventAnalytics operation will return all of the summary columns.

        To filter for a specific summary column, specify it in the summaryField query parameter.

        *Example:** /auditEventAnalytics?summaryField=targetName&summaryField=userName&summaryField=clientHostname &summaryField=dmls&summaryField=privilegeChanges&summaryField=ddls&summaryField=loginFailure&summaryField=loginSuccess &summaryField=allRecord&scimQuery=(auditEventTime ge \"2021-06-13T23:49:14\")

        /auditEventAnalytics?timeStarted=2022-08-18T11:02:26.000Z&timeEnded=2022-08-24T11:02:26.000Z This will give number of events grouped by periods. Period can be 1 day, 1 week, etc.

        /auditEventAnalytics?summaryField=targetName&groupBy=targetName This will give the number of events group by targetName. Only targetName summary column would be returned.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listAuditEvents

        Future<ListAuditEventsResponse> listAuditEvents​(ListAuditEventsRequest request,
                                                AsyncHandler<ListAuditEventsRequest,​ListAuditEventsResponse> handler)
        The ListAuditEvents operation returns specified compartmentId audit Events only.

        The list does not include any audit Events associated with the subcompartments of the specified compartmentId.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListAuditEvents on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listAuditPolicies

        Future<ListAuditPoliciesResponse> listAuditPolicies​(ListAuditPoliciesRequest request,
                                                    AsyncHandler<ListAuditPoliciesRequest,​ListAuditPoliciesResponse> handler)
        Retrieves a list of all audited targets with their corresponding provisioned audit policies, and their provisioning conditions.

        The ListAuditPolicies operation returns only the audit policies in the specified `compartmentId`. The list does not include any subcompartments of the compartmentId passed.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListAuditPolicies on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listAuditPolicyAnalytics

        Future<ListAuditPolicyAnalyticsResponse> listAuditPolicyAnalytics​(ListAuditPolicyAnalyticsRequest request,
                                                                  AsyncHandler<ListAuditPolicyAnalyticsRequest,​ListAuditPolicyAnalyticsResponse> handler)
        Gets a list of aggregated audit policy details on the target databases.

        A audit policy aggregation helps understand the overall state of policies provisioned on targets. It is especially useful to create dashboards or to support analytics.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform SummarizedAuditPolicyInfo on the specified `compartmentId` and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        *Example:** ListAuditPolicyAnalytics?groupBy=auditPolicyCategory

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listAuditProfileAnalytics

        Future<ListAuditProfileAnalyticsResponse> listAuditProfileAnalytics​(ListAuditProfileAnalyticsRequest request,
                                                                    AsyncHandler<ListAuditProfileAnalyticsRequest,​ListAuditProfileAnalyticsResponse> handler)
        Gets a list of audit profile aggregated details .

        A audit profile aggregation helps understand the overall state of audit profile profiles. As an example, it helps understand how many audit profiles have paid usage. It is especially useful to create dashboards or to support analytics.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform AuditProfileAnalytics on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listAuditProfiles

        Future<ListAuditProfilesResponse> listAuditProfiles​(ListAuditProfilesRequest request,
                                                    AsyncHandler<ListAuditProfilesRequest,​ListAuditProfilesResponse> handler)
        Gets a list of all audit profiles.

        The ListAuditProfiles operation returns only the audit profiles in the specified `compartmentId`. The list does not include any subcompartments of the compartmentId passed.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListAuditProfiles on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listAuditTrailAnalytics

        Future<ListAuditTrailAnalyticsResponse> listAuditTrailAnalytics​(ListAuditTrailAnalyticsRequest request,
                                                                AsyncHandler<ListAuditTrailAnalyticsRequest,​ListAuditTrailAnalyticsResponse> handler)
        Gets a list of audit trail aggregated details .

        A audit trail aggregation helps understand the overall state of trails. As an example, it helps understand how many trails are running or stopped. It is especially useful to create dashboards or to support analytics.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform AuditTrailAnalytics on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listAuditTrails

        Future<ListAuditTrailsResponse> listAuditTrails​(ListAuditTrailsRequest request,
                                                AsyncHandler<ListAuditTrailsRequest,​ListAuditTrailsResponse> handler)
        Gets a list of all audit trails.

        The ListAuditTrails operation returns only the audit trails in the specified compartmentId. The list does not include any subcompartments of the compartmentId passed.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListAuditTrails on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listAvailableAuditVolumes

        Future<ListAvailableAuditVolumesResponse> listAvailableAuditVolumes​(ListAvailableAuditVolumesRequest request,
                                                                    AsyncHandler<ListAvailableAuditVolumesRequest,​ListAvailableAuditVolumesResponse> handler)
        Retrieves a list of audit trails, and associated audit event volume for each trail up to defined start date.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listChecks

        Future<ListChecksResponse> listChecks​(ListChecksRequest request,
                                      AsyncHandler<ListChecksRequest,​ListChecksResponse> handler)
        Lists all the security checks in the specified compartment for security assessment of type TEMPLATE.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listColumns

        Future<ListColumnsResponse> listColumns​(ListColumnsRequest request,
                                        AsyncHandler<ListColumnsRequest,​ListColumnsResponse> handler)
        Returns a list of column metadata objects.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listDatabaseSecurityConfigs

        Future<ListDatabaseSecurityConfigsResponse> listDatabaseSecurityConfigs​(ListDatabaseSecurityConfigsRequest request,
                                                                        AsyncHandler<ListDatabaseSecurityConfigsRequest,​ListDatabaseSecurityConfigsResponse> handler)
        Retrieves a list of all database security configurations in Data Safe.

        The ListDatabaseSecurityConfigs operation returns only the database security configurations in the specified `compartmentId`.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListDatabaseSecurityConfigs on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listDatabaseTableAccessEntries

        Future<ListDatabaseTableAccessEntriesResponse> listDatabaseTableAccessEntries​(ListDatabaseTableAccessEntriesRequest request,
                                                                              AsyncHandler<ListDatabaseTableAccessEntriesRequest,​ListDatabaseTableAccessEntriesResponse> handler)
        Retrieves a list of all database table access entries in Data Safe.

        The ListDatabaseTableAccessEntries operation returns only the database table access reports for the specified security policy report.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listDatabaseViewAccessEntries

        Future<ListDatabaseViewAccessEntriesResponse> listDatabaseViewAccessEntries​(ListDatabaseViewAccessEntriesRequest request,
                                                                            AsyncHandler<ListDatabaseViewAccessEntriesRequest,​ListDatabaseViewAccessEntriesResponse> handler)
        Retrieves a list of all database view access entries in Data Safe.

        The ListDatabaseViewAccessEntries operation returns only the database view access objects for the specified security policy report.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listDifferenceColumns

        Future<ListDifferenceColumnsResponse> listDifferenceColumns​(ListDifferenceColumnsRequest request,
                                                            AsyncHandler<ListDifferenceColumnsRequest,​ListDifferenceColumnsResponse> handler)
        Gets a list of columns of a SDM masking policy difference resource based on the specified query parameters.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listDiscoveryAnalytics

        Future<ListDiscoveryAnalyticsResponse> listDiscoveryAnalytics​(ListDiscoveryAnalyticsRequest request,
                                                              AsyncHandler<ListDiscoveryAnalyticsRequest,​ListDiscoveryAnalyticsResponse> handler)
        Gets consolidated discovery analytics data based on the specified query parameters.

        If CompartmentIdInSubtreeQueryParam is specified as true, the behaviour is equivalent to accessLevel "ACCESSIBLE" by default.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listDiscoveryJobResults

        Future<ListDiscoveryJobResultsResponse> listDiscoveryJobResults​(ListDiscoveryJobResultsRequest request,
                                                                AsyncHandler<ListDiscoveryJobResultsRequest,​ListDiscoveryJobResultsResponse> handler)
        Gets a list of discovery results based on the specified query parameters.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listDiscoveryJobs

        Future<ListDiscoveryJobsResponse> listDiscoveryJobs​(ListDiscoveryJobsRequest request,
                                                    AsyncHandler<ListDiscoveryJobsRequest,​ListDiscoveryJobsResponse> handler)
        Gets a list of incremental discovery jobs based on the specified query parameters.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listFindingAnalytics

        Future<ListFindingAnalyticsResponse> listFindingAnalytics​(ListFindingAnalyticsRequest request,
                                                          AsyncHandler<ListFindingAnalyticsRequest,​ListFindingAnalyticsResponse> handler)
        Gets a list of findings aggregated details in the specified compartment.

        This provides information about the overall state of security assessment findings. You can use groupBy to get the count of findings under a certain risk level and with a certain findingKey, and as well as get the list of the targets that match the condition. This data is especially useful content for the statistic chart or to support analytics.

        When you perform the ListFindingAnalytics operation, if the parameter compartmentIdInSubtree is set to \"true,\" and if the parameter accessLevel is set to ACCESSIBLE, then the operation returns statistics from the compartments in which the requestor has INSPECT permissions on at least one resource, directly or indirectly (in subcompartments). If the operation is performed at the root compartment and the requestor does not have access to at least one subcompartment of the compartment specified by compartmentId, then \"Not Authorized\" is returned.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listFindings

        Future<ListFindingsResponse> listFindings​(ListFindingsRequest request,
                                          AsyncHandler<ListFindingsRequest,​ListFindingsResponse> handler)
        Lists all the findings for the specified assessment except for type TEMPLATE.

        If the assessment is of type TEMPLATE_BASELINE, the findings returned are the security checks with the user-defined severity from the template.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listGrants

        Future<ListGrantsResponse> listGrants​(ListGrantsRequest request,
                                      AsyncHandler<ListGrantsRequest,​ListGrantsResponse> handler)
        Gets a list of grants for a particular user in the specified user assessment.

        A user grant contains details such as the privilege name, type, category, and depth level. The depth level indicates how deep in the hierarchy of roles granted to roles a privilege grant is. The userKey in this operation is a system-generated identifier. Perform the operation ListUsers to get the userKey for a particular user.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listGroupedSensitiveTypes

        Future<ListGroupedSensitiveTypesResponse> listGroupedSensitiveTypes​(ListGroupedSensitiveTypesRequest request,
                                                                    AsyncHandler<ListGroupedSensitiveTypesRequest,​ListGroupedSensitiveTypesResponse> handler)
        Gets the list of sensitive type Ids present in the specified sensitive type group.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listLibraryMaskingFormats

        Future<ListLibraryMaskingFormatsResponse> listLibraryMaskingFormats​(ListLibraryMaskingFormatsRequest request,
                                                                    AsyncHandler<ListLibraryMaskingFormatsRequest,​ListLibraryMaskingFormatsResponse> handler)
        Gets a list of library masking formats based on the specified query parameters.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listMaskedColumns

        Future<ListMaskedColumnsResponse> listMaskedColumns​(ListMaskedColumnsRequest request,
                                                    AsyncHandler<ListMaskedColumnsRequest,​ListMaskedColumnsResponse> handler)
        Gets a list of masked columns present in the specified masking report and based on the specified query parameters.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listMaskingAnalytics

        Future<ListMaskingAnalyticsResponse> listMaskingAnalytics​(ListMaskingAnalyticsRequest request,
                                                          AsyncHandler<ListMaskingAnalyticsRequest,​ListMaskingAnalyticsResponse> handler)
        Gets consolidated masking analytics data based on the specified query parameters.

        If CompartmentIdInSubtreeQueryParam is specified as true, the behaviour is equivalent to accessLevel "ACCESSIBLE" by default.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listMaskingColumns

        Future<ListMaskingColumnsResponse> listMaskingColumns​(ListMaskingColumnsRequest request,
                                                      AsyncHandler<ListMaskingColumnsRequest,​ListMaskingColumnsResponse> handler)
        Gets a list of masking columns present in the specified masking policy and based on the specified query parameters.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listMaskingErrors

        Future<ListMaskingErrorsResponse> listMaskingErrors​(ListMaskingErrorsRequest request,
                                                    AsyncHandler<ListMaskingErrorsRequest,​ListMaskingErrorsResponse> handler)
        Gets a list of masking errors in a masking run based on the specified query parameters.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listMaskingObjects

        Future<ListMaskingObjectsResponse> listMaskingObjects​(ListMaskingObjectsRequest request,
                                                      AsyncHandler<ListMaskingObjectsRequest,​ListMaskingObjectsResponse> handler)
        Gets a list of masking objects present in the specified masking policy and based on the specified query parameters.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listMaskingPolicies

        Future<ListMaskingPoliciesResponse> listMaskingPolicies​(ListMaskingPoliciesRequest request,
                                                        AsyncHandler<ListMaskingPoliciesRequest,​ListMaskingPoliciesResponse> handler)
        Gets a list of masking policies based on the specified query parameters.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listMaskingReports

        Future<ListMaskingReportsResponse> listMaskingReports​(ListMaskingReportsRequest request,
                                                      AsyncHandler<ListMaskingReportsRequest,​ListMaskingReportsResponse> handler)
        Gets a list of masking reports based on the specified query parameters.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listMaskingSchemas

        Future<ListMaskingSchemasResponse> listMaskingSchemas​(ListMaskingSchemasRequest request,
                                                      AsyncHandler<ListMaskingSchemasRequest,​ListMaskingSchemasResponse> handler)
        Gets a list of masking schemas present in the specified masking policy and based on the specified query parameters.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listOnPremConnectors

        Future<ListOnPremConnectorsResponse> listOnPremConnectors​(ListOnPremConnectorsRequest request,
                                                          AsyncHandler<ListOnPremConnectorsRequest,​ListOnPremConnectorsResponse> handler)
        Gets a list of on-premises connectors.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listPasswordExpiryDateAnalytics

        Future<ListPasswordExpiryDateAnalyticsResponse> listPasswordExpiryDateAnalytics​(ListPasswordExpiryDateAnalyticsRequest request,
                                                                                AsyncHandler<ListPasswordExpiryDateAnalyticsRequest,​ListPasswordExpiryDateAnalyticsResponse> handler)
        Gets a list of count of the users with password expiry dates in next 30 days, between next 30-90 days, and beyond 90 days based on specified user assessment.

        It internally uses the aforementioned userAnalytics api.

        When you perform the ListPasswordExpiryDateAnalytics operation, if the parameter compartmentIdInSubtree is set to \"true,\" and if the parameter accessLevel is set to ACCESSIBLE, then the operation returns compartments in which the requestor has READ permissions on at least one resource, directly or indirectly (in subcompartments). If the operation is performed at the root compartment and the requestor does not have access to at least one subcompartment of the compartment specified by compartmentId, then \"Not Authorized\" is returned.

        To use ListPasswordExpiryDateAnalytics to get a full list of all compartments and subcompartments in the tenancy from the root compartment, set the parameter compartmentIdInSubtree to true and accessLevel to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listPeerTargetDatabases

        Future<ListPeerTargetDatabasesResponse> listPeerTargetDatabases​(ListPeerTargetDatabasesRequest request,
                                                                AsyncHandler<ListPeerTargetDatabasesRequest,​ListPeerTargetDatabasesResponse> handler)
        Lists all the peer target databases under the primary target database identified by the OCID passed as path parameter.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listProfileAnalytics

        Future<ListProfileAnalyticsResponse> listProfileAnalytics​(ListProfileAnalyticsRequest request,
                                                          AsyncHandler<ListProfileAnalyticsRequest,​ListProfileAnalyticsResponse> handler)
        Gets a list of aggregated user profile details in the specified compartment.

        This provides information about the overall profiles available. For example, the user profile details include how many users have the profile assigned and do how many use password verification function. This data is especially useful content for dashboards or to support analytics.

        When you perform the ListProfileAnalytics operation, if the parameter compartmentIdInSubtree is set to \"true,\" and if the parameter accessLevel is set to ACCESSIBLE, then the operation returns compartments in which the requestor has INSPECT permissions on at least one resource, directly or indirectly (in subcompartments). If the operation is performed at the root compartment and the requestor does not have access to at least one subcompartment of the compartment specified by compartmentId, then \"Not Authorized\" is returned.

        The parameter compartmentIdInSubtree applies when you perform ListProfileAnalytics on the compartmentId passed and when it is set to true, the entire hierarchy of compartments can be returned.

        To use ListProfileAnalytics to get a full list of all compartments and subcompartments in the tenancy from the root compartment, set the parameter compartmentIdInSubtree to true and accessLevel to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listProfileSummaries

        Future<ListProfileSummariesResponse> listProfileSummaries​(ListProfileSummariesRequest request,
                                                          AsyncHandler<ListProfileSummariesRequest,​ListProfileSummariesResponse> handler)
        Gets a list of user profiles containing the profile details along with the target id and user counts.

        The ListProfiles operation returns only the profiles belonging to a certain target. If compartment type user assessment id is provided, then profile information for all the targets belonging to the pertaining compartment is returned. The list does not include any subcompartments of the compartment under consideration.

        The parameter 'accessLevel' specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when 'compartmentIdInSubtree' is set to 'true'.

        The parameter 'compartmentIdInSubtree' applies when you perform ListUserProfiles on the 'compartmentId' belonging to the assessmentId passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter 'compartmentIdInSubtree' to true and 'accessLevel' to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listReferentialRelations

        Future<ListReferentialRelationsResponse> listReferentialRelations​(ListReferentialRelationsRequest request,
                                                                  AsyncHandler<ListReferentialRelationsRequest,​ListReferentialRelationsResponse> handler)
        Gets a list of referential relations present in the specified sensitive data model based on the specified query parameters.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listReportDefinitions

        Future<ListReportDefinitionsResponse> listReportDefinitions​(ListReportDefinitionsRequest request,
                                                            AsyncHandler<ListReportDefinitionsRequest,​ListReportDefinitionsResponse> handler)
        Gets a list of report definitions.

        The ListReportDefinitions operation returns only the report definitions in the specified compartmentId. It also returns the seeded report definitions which are available to all the compartments.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listReports

        Future<ListReportsResponse> listReports​(ListReportsRequest request,
                                        AsyncHandler<ListReportsRequest,​ListReportsResponse> handler)
        Gets a list of all the reports in the compartment.

        It contains information such as report generation time.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listRoleGrantPaths

        Future<ListRoleGrantPathsResponse> listRoleGrantPaths​(ListRoleGrantPathsRequest request,
                                                      AsyncHandler<ListRoleGrantPathsRequest,​ListRoleGrantPathsResponse> handler)
        Retrieves a list of all role grant paths for a particular user.

        The ListRoleGrantPaths operation returns only the role grant paths for the specified security policy report.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listRoles

        Future<ListRolesResponse> listRoles​(ListRolesRequest request,
                                    AsyncHandler<ListRolesRequest,​ListRolesResponse> handler)
        Returns a list of role metadata objects.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSchemas

        Future<ListSchemasResponse> listSchemas​(ListSchemasRequest request,
                                        AsyncHandler<ListSchemasRequest,​ListSchemasResponse> handler)
        Returns list of schema.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSecurityAssessments

        Future<ListSecurityAssessmentsResponse> listSecurityAssessments​(ListSecurityAssessmentsRequest request,
                                                                AsyncHandler<ListSecurityAssessmentsRequest,​ListSecurityAssessmentsResponse> handler)
        Gets a list of security assessments.

        The ListSecurityAssessments operation returns only the assessments in the specified `compartmentId`. The list does not include any subcompartments of the compartmentId passed.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListSecurityAssessments on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSecurityFeatureAnalytics

        Future<ListSecurityFeatureAnalyticsResponse> listSecurityFeatureAnalytics​(ListSecurityFeatureAnalyticsRequest request,
                                                                          AsyncHandler<ListSecurityFeatureAnalyticsRequest,​ListSecurityFeatureAnalyticsResponse> handler)
        Gets a list of Database security feature usage aggregated details in the specified compartment.

        This provides information about the overall security controls, by returning the counting number of the target databases using the security features.

        When you perform the ListSecurityFeatureAnalytics operation, if the parameter compartmentIdInSubtree is set to \"true,\" and if the parameter accessLevel is set to ACCESSIBLE, then the operation returns statistics from the compartments in which the requestor has INSPECT permissions on at least one resource, directly or indirectly (in subcompartments). If the operation is performed at the root compartment and the requestor does not have access to at least one subcompartment of the compartment specified by compartmentId, then \"Not Authorized\" is returned.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSecurityFeatures

        Future<ListSecurityFeaturesResponse> listSecurityFeatures​(ListSecurityFeaturesRequest request,
                                                          AsyncHandler<ListSecurityFeaturesRequest,​ListSecurityFeaturesResponse> handler)
        Lists the usage of Database security features for a given compartment or a target level, based on the filters provided.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSecurityPolicies

        Future<ListSecurityPoliciesResponse> listSecurityPolicies​(ListSecurityPoliciesRequest request,
                                                          AsyncHandler<ListSecurityPoliciesRequest,​ListSecurityPoliciesResponse> handler)
        Retrieves a list of all security policies in Data Safe.

        The ListSecurityPolicies operation returns only the security policies in the specified `compartmentId`.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListSecurityPolicies on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSecurityPolicyConfigs

        Future<ListSecurityPolicyConfigsResponse> listSecurityPolicyConfigs​(ListSecurityPolicyConfigsRequest request,
                                                                    AsyncHandler<ListSecurityPolicyConfigsRequest,​ListSecurityPolicyConfigsResponse> handler)
        Retrieves a list of all security policy configurations in Data Safe.

        The ListSecurityPolicyConfigs operation returns only the security policy configurations in the specified `compartmentId`.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListSecurityPolicyConfigs on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSecurityPolicyDeployments

        Future<ListSecurityPolicyDeploymentsResponse> listSecurityPolicyDeployments​(ListSecurityPolicyDeploymentsRequest request,
                                                                            AsyncHandler<ListSecurityPolicyDeploymentsRequest,​ListSecurityPolicyDeploymentsResponse> handler)
        Retrieves a list of all security policy deployments in Data Safe.

        The ListSecurityPolicyDeployments operation returns only the security policy deployments in the specified `compartmentId`.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListSecurityPolicyDeployments on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSecurityPolicyEntryStates

        Future<ListSecurityPolicyEntryStatesResponse> listSecurityPolicyEntryStates​(ListSecurityPolicyEntryStatesRequest request,
                                                                            AsyncHandler<ListSecurityPolicyEntryStatesRequest,​ListSecurityPolicyEntryStatesResponse> handler)
        Retrieves a list of all security policy entry states in Data Safe.

        The ListSecurityPolicyEntryStates operation returns only the security policy entry states for the specified security policy entry.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSecurityPolicyReports

        Future<ListSecurityPolicyReportsResponse> listSecurityPolicyReports​(ListSecurityPolicyReportsRequest request,
                                                                    AsyncHandler<ListSecurityPolicyReportsRequest,​ListSecurityPolicyReportsResponse> handler)
        Retrieves a list of all security policy reports in Data Safe.

        The ListSecurityPolicyReports operation returns only the security policy reports in the specified `compartmentId`.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListSecurityPolicyReports on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSensitiveColumnAnalytics

        Future<ListSensitiveColumnAnalyticsResponse> listSensitiveColumnAnalytics​(ListSensitiveColumnAnalyticsRequest request,
                                                                          AsyncHandler<ListSensitiveColumnAnalyticsRequest,​ListSensitiveColumnAnalyticsResponse> handler)
        Gets consolidated sensitive columns analytics data based on the specified query parameters.

        When you perform the ListSensitiveColumnAnalytics operation, if the parameter compartmentIdInSubtree is set to \"true,\" and if the parameter accessLevel is set to ACCESSIBLE, then the operation returns compartments in which the requestor has INSPECT permissions on at least one resource, directly or indirectly (in subcompartments). If the operation is performed at the root compartment and the requestor does not have access to at least one subcompartment of the compartment specified by compartmentId, then \"Not Authorized\" is returned.

        To use ListSensitiveColumnAnalytics to get a full list of all compartments and subcompartments in the tenancy from the root compartment, set the parameter compartmentIdInSubtree to true and accessLevel to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSensitiveColumns

        Future<ListSensitiveColumnsResponse> listSensitiveColumns​(ListSensitiveColumnsRequest request,
                                                          AsyncHandler<ListSensitiveColumnsRequest,​ListSensitiveColumnsResponse> handler)
        Gets a list of sensitive columns present in the specified sensitive data model based on the specified query parameters.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSensitiveDataModels

        Future<ListSensitiveDataModelsResponse> listSensitiveDataModels​(ListSensitiveDataModelsRequest request,
                                                                AsyncHandler<ListSensitiveDataModelsRequest,​ListSensitiveDataModelsResponse> handler)
        Gets a list of sensitive data models based on the specified query parameters.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSensitiveObjects

        Future<ListSensitiveObjectsResponse> listSensitiveObjects​(ListSensitiveObjectsRequest request,
                                                          AsyncHandler<ListSensitiveObjectsRequest,​ListSensitiveObjectsResponse> handler)
        Gets a list of sensitive objects present in the specified sensitive data model based on the specified query parameters.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSensitiveSchemas

        Future<ListSensitiveSchemasResponse> listSensitiveSchemas​(ListSensitiveSchemasRequest request,
                                                          AsyncHandler<ListSensitiveSchemasRequest,​ListSensitiveSchemasResponse> handler)
        Gets a list of sensitive schemas present in the specified sensitive data model based on the specified query parameters.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSensitiveTypeGroups

        Future<ListSensitiveTypeGroupsResponse> listSensitiveTypeGroups​(ListSensitiveTypeGroupsRequest request,
                                                                AsyncHandler<ListSensitiveTypeGroupsRequest,​ListSensitiveTypeGroupsResponse> handler)
        Gets a list of sensitive type groups based on the specified query parameters.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSensitiveTypes

        Future<ListSensitiveTypesResponse> listSensitiveTypes​(ListSensitiveTypesRequest request,
                                                      AsyncHandler<ListSensitiveTypesRequest,​ListSensitiveTypesResponse> handler)
        Gets a list of sensitive types based on the specified query parameters.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSensitiveTypesExports

        Future<ListSensitiveTypesExportsResponse> listSensitiveTypesExports​(ListSensitiveTypesExportsRequest request,
                                                                    AsyncHandler<ListSensitiveTypesExportsRequest,​ListSensitiveTypesExportsResponse> handler)
        Retrieves a list of all sensitive types export in Data Safe based on the specified query parameters.

        The ListSensitiveTypesExports operation returns only the sensitive types export in the specified compartmentId.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSqlCollectionAnalytics

        Future<ListSqlCollectionAnalyticsResponse> listSqlCollectionAnalytics​(ListSqlCollectionAnalyticsRequest request,
                                                                      AsyncHandler<ListSqlCollectionAnalyticsRequest,​ListSqlCollectionAnalyticsResponse> handler)
        Retrieves a list of all SQL collection analytics in Data Safe.

        The ListSqlCollectionAnalytics operation returns only the analytics for the SQL collections in the specified `compartmentId`.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListSqlCollections on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSqlCollections

        Future<ListSqlCollectionsResponse> listSqlCollections​(ListSqlCollectionsRequest request,
                                                      AsyncHandler<ListSqlCollectionsRequest,​ListSqlCollectionsResponse> handler)
        Retrieves a list of all SQL collections in Data Safe.

        The ListSqlCollections operation returns only the SQL collections in the specified `compartmentId`.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListSqlCollections on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSqlFirewallAllowedSqlAnalytics

        Future<ListSqlFirewallAllowedSqlAnalyticsResponse> listSqlFirewallAllowedSqlAnalytics​(ListSqlFirewallAllowedSqlAnalyticsRequest request,
                                                                                      AsyncHandler<ListSqlFirewallAllowedSqlAnalyticsRequest,​ListSqlFirewallAllowedSqlAnalyticsResponse> handler)
        Returns the aggregation details of all SQL Firewall allowed SQL statements.

        The ListSqlFirewallAllowedSqlAnalytics operation returns the aggregates of the SQL Firewall allowed SQL statements in the specified `compartmentId`.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListSqlFirewallAllowedSqlAnalytics on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSqlFirewallAllowedSqls

        Future<ListSqlFirewallAllowedSqlsResponse> listSqlFirewallAllowedSqls​(ListSqlFirewallAllowedSqlsRequest request,
                                                                      AsyncHandler<ListSqlFirewallAllowedSqlsRequest,​ListSqlFirewallAllowedSqlsResponse> handler)
        Retrieves a list of all SQL Firewall allowed SQL statements.

        The ListSqlFirewallAllowedSqls operation returns only the SQL Firewall allowed SQL statements in the specified `compartmentId`.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListSqlFirewallPolicies on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSqlFirewallPolicies

        Future<ListSqlFirewallPoliciesResponse> listSqlFirewallPolicies​(ListSqlFirewallPoliciesRequest request,
                                                                AsyncHandler<ListSqlFirewallPoliciesRequest,​ListSqlFirewallPoliciesResponse> handler)
        Retrieves a list of all SQL Firewall policies.

        The ListSqlFirewallPolicies operation returns only the SQL Firewall policies in the specified `compartmentId`.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListSqlFirewallPolicies on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSqlFirewallPolicyAnalytics

        Future<ListSqlFirewallPolicyAnalyticsResponse> listSqlFirewallPolicyAnalytics​(ListSqlFirewallPolicyAnalyticsRequest request,
                                                                              AsyncHandler<ListSqlFirewallPolicyAnalyticsRequest,​ListSqlFirewallPolicyAnalyticsResponse> handler)
        Gets a list of aggregated SQL Firewall policy details.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform SummarizedSqlFirewallPolicyInfo on the specified `compartmentId` and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSqlFirewallViolations

        Future<ListSqlFirewallViolationsResponse> listSqlFirewallViolations​(ListSqlFirewallViolationsRequest request,
                                                                    AsyncHandler<ListSqlFirewallViolationsRequest,​ListSqlFirewallViolationsResponse> handler)
        Gets a list of all the SQL Firewall violations captured by the firewall.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listTables

        Future<ListTablesResponse> listTables​(ListTablesRequest request,
                                      AsyncHandler<ListTablesRequest,​ListTablesResponse> handler)
        Returns a list of table metadata objects.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listTargetDatabaseGroups

        Future<ListTargetDatabaseGroupsResponse> listTargetDatabaseGroups​(ListTargetDatabaseGroupsRequest request,
                                                                  AsyncHandler<ListTargetDatabaseGroupsRequest,​ListTargetDatabaseGroupsResponse> handler)
        Retrieves a list of target database groups according to the specified query parameters.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listTargetDatabases

        Future<ListTargetDatabasesResponse> listTargetDatabases​(ListTargetDatabasesRequest request,
                                                        AsyncHandler<ListTargetDatabasesRequest,​ListTargetDatabasesResponse> handler)
        Returns the list of registered target databases in Data Safe.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listTargetOverrides

        Future<ListTargetOverridesResponse> listTargetOverrides​(ListTargetOverridesRequest request,
                                                        AsyncHandler<ListTargetOverridesRequest,​ListTargetOverridesResponse> handler)
        Gets a list of all targets whose audit settings override the target group setting.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listTemplateAnalytics

        Future<ListTemplateAnalyticsResponse> listTemplateAnalytics​(ListTemplateAnalyticsRequest request,
                                                            AsyncHandler<ListTemplateAnalyticsRequest,​ListTemplateAnalyticsResponse> handler)
        Gets a list of template aggregated details in the specified compartment.

        This provides information about the overall template usage, by returning the count of the target databases/target groups using the templates. It also provides information about the statistics for the template baseline and the comparison related. If the comparison is done, it will show if there is any drift, and how many checks have drifts. The dimension field - isGroup identifies if the targetId belongs to a target group or a individual target. The dimension field - isCompared identifies if the comparison between the latest assessment and the template baseline assessment is done or not. The dimension field - isCompliant identifies if the latest assessment is compliant with the template baseline assessment or not. The dimension field - totalChecksFailed identifies how many checks in the template have drifts in the comparison.

        When you perform the ListTemplateAnalytics operation, if the parameter compartmentIdInSubtree is set to \"true,\" and if the parameter accessLevel is set to ACCESSIBLE, then the operation returns statistics from the compartments in which the requestor has INSPECT permissions on at least one resource, directly or indirectly (in subcompartments). If the operation is performed at the root compartment and the requestor does not have access to at least one subcompartment of the compartment specified by compartmentId, then \"Not Authorized\" is returned.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listTemplateAssociationAnalytics

        Future<ListTemplateAssociationAnalyticsResponse> listTemplateAssociationAnalytics​(ListTemplateAssociationAnalyticsRequest request,
                                                                                  AsyncHandler<ListTemplateAssociationAnalyticsRequest,​ListTemplateAssociationAnalyticsResponse> handler)
        Gets a list of template association details in the specified compartment.

        This provides information about the overall template usage, by returning the count of the target databases/target groups using the templates.

        If the template baseline is created for a target group which contains several targets, we will have each individual target listed there as targetId field together with targetDatabaseGroupId. And if the template baseline is created for an individual target, it will have targetId field only.

        By leveraging the targetId filter, you will be able to know all the template or template baseline that this target has something to do with. No matter if they are directly applied or created for this target, or they are for the target group the target belongs to.

        When you perform the ListTemplateAssociationAnalytics operation, if the parameter compartmentIdInSubtree is set to \"true,\" and if the parameter accessLevel is set to ACCESSIBLE, then the operation returns statistics from the compartments in which the requestor has INSPECT permissions on at least one resource, directly or indirectly (in subcompartments). If the operation is performed at the root compartment and the requestor does not have access to at least one subcompartment of the compartment specified by compartmentId, then \"Not Authorized\" is returned.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listUnifiedAuditPolicies

        Future<ListUnifiedAuditPoliciesResponse> listUnifiedAuditPolicies​(ListUnifiedAuditPoliciesRequest request,
                                                                  AsyncHandler<ListUnifiedAuditPoliciesRequest,​ListUnifiedAuditPoliciesResponse> handler)
        Retrieves a list of all Unified Audit policies.

        The ListUnifiedAuditPolicies operation returns only the Unified Audit policies in the specified `compartmentId`.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requester has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a sub-compartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListUnifiedAuditPolicies on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and sub-compartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listUnifiedAuditPolicyDefinitions

        Future<ListUnifiedAuditPolicyDefinitionsResponse> listUnifiedAuditPolicyDefinitions​(ListUnifiedAuditPolicyDefinitionsRequest request,
                                                                                    AsyncHandler<ListUnifiedAuditPolicyDefinitionsRequest,​ListUnifiedAuditPolicyDefinitionsResponse> handler)
        Retrieves a list of all unified audit policy definitions in Data Safe.

        The ListUnifiedAuditPolicyDefinitions operation returns only the unified audit policy definitions in the specified `compartmentId`.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requester has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListUnifiedAuditPolicyDefinitions on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listUserAccessAnalytics

        Future<ListUserAccessAnalyticsResponse> listUserAccessAnalytics​(ListUserAccessAnalyticsRequest request,
                                                                AsyncHandler<ListUserAccessAnalyticsRequest,​ListUserAccessAnalyticsResponse> handler)
        Gets a list of aggregated user access analytics in the specified target in a compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listUserAnalytics

        Future<ListUserAnalyticsResponse> listUserAnalytics​(ListUserAnalyticsRequest request,
                                                    AsyncHandler<ListUserAnalyticsRequest,​ListUserAnalyticsResponse> handler)
        Gets a list of aggregated user details from the specified user assessment.

        This provides information about the overall state. of database user security. For example, the user details include how many users have the DBA role and how many users are in the critical category. This data is especially useful content for dashboards or to support analytics.

        When you perform the ListUserAnalytics operation, if the parameter compartmentIdInSubtree is set to \"true,\" and if the parameter accessLevel is set to ACCESSIBLE, then the operation returns compartments in which the requestor has READ permissions on at least one resource, directly or indirectly (in subcompartments). If the operation is performed at the root compartment and the requestor does not have access to at least one subcompartment of the compartment specified by compartmentId, then \"Not Authorized\" is returned.

        The parameter compartmentIdInSubtree applies when you perform ListUserAnalytics on the compartmentId passed and when it is set to true, the entire hierarchy of compartments can be returned.

        To use ListUserAnalytics to get a full list of all compartments and subcompartments in the tenancy from the root compartment, set the parameter compartmentIdInSubtree to true and accessLevel to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listUserAssessments

        Future<ListUserAssessmentsResponse> listUserAssessments​(ListUserAssessmentsRequest request,
                                                        AsyncHandler<ListUserAssessmentsRequest,​ListUserAssessmentsResponse> handler)
        Gets a list of user assessments.

        The ListUserAssessments operation returns only the assessments in the specified `compartmentId`. The list does not include any subcompartments of the compartmentId passed.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListUserAssessments on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listUsers

        Future<ListUsersResponse> listUsers​(ListUsersRequest request,
                                    AsyncHandler<ListUsersRequest,​ListUsersResponse> handler)
        Gets a list of users of the specified user assessment.

        The result contains the database user details for each user, such as user type, account status, last login time, user creation time, authentication type, user profile, and the date and time of the latest password change. It also contains the user category derived from these user details as well as privileges granted to each user.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listWorkRequestErrors

        Future<ListWorkRequestErrorsResponse> listWorkRequestErrors​(ListWorkRequestErrorsRequest request,
                                                            AsyncHandler<ListWorkRequestErrorsRequest,​ListWorkRequestErrorsResponse> handler)
        Gets a list of errors for the specified work request.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listWorkRequestLogs

        Future<ListWorkRequestLogsResponse> listWorkRequestLogs​(ListWorkRequestLogsRequest request,
                                                        AsyncHandler<ListWorkRequestLogsRequest,​ListWorkRequestLogsResponse> handler)
        Gets a list of log entries for the specified work request.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listWorkRequests

        Future<ListWorkRequestsResponse> listWorkRequests​(ListWorkRequestsRequest request,
                                                  AsyncHandler<ListWorkRequestsRequest,​ListWorkRequestsResponse> handler)
        Gets a list of work requests.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • maskData

        Future<MaskDataResponse> maskData​(MaskDataRequest request,
                                  AsyncHandler<MaskDataRequest,​MaskDataResponse> handler)
        Masks data using the specified masking policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • modifyGlobalSettings

        Future<ModifyGlobalSettingsResponse> modifyGlobalSettings​(ModifyGlobalSettingsRequest request,
                                                          AsyncHandler<ModifyGlobalSettingsRequest,​ModifyGlobalSettingsResponse> handler)
        Modifies Global Settings in Data Safe in the tenancy and region.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • patchAlerts

        Future<PatchAlertsResponse> patchAlerts​(PatchAlertsRequest request,
                                        AsyncHandler<PatchAlertsRequest,​PatchAlertsResponse> handler)
        Updates the status of one or more alert specified by the alert IDs.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • patchChecks

        Future<PatchChecksResponse> patchChecks​(PatchChecksRequest request,
                                        AsyncHandler<PatchChecksRequest,​PatchChecksResponse> handler)
        Patches one or more checks in the specified template type security assessment.

        Use it to add or delete checks. To add check, use CreateCheckDetails as the patch value.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • patchDiscoveryJobResults

        Future<PatchDiscoveryJobResultsResponse> patchDiscoveryJobResults​(PatchDiscoveryJobResultsRequest request,
                                                                  AsyncHandler<PatchDiscoveryJobResultsRequest,​PatchDiscoveryJobResultsResponse> handler)
        Patches one or more discovery results.

        You can use this operation to set the plannedAction attribute before using ApplyDiscoveryJobResults to process the results based on this attribute.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • patchFindings

        Future<PatchFindingsResponse> patchFindings​(PatchFindingsRequest request,
                                            AsyncHandler<PatchFindingsRequest,​PatchFindingsResponse> handler)
        Patches one or more findings in the specified template baseline type security assessment.

        Use it to modify max allowed risk level in template baseline.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • patchGroupedSensitiveTypes

        Future<PatchGroupedSensitiveTypesResponse> patchGroupedSensitiveTypes​(PatchGroupedSensitiveTypesRequest request,
                                                                      AsyncHandler<PatchGroupedSensitiveTypesRequest,​PatchGroupedSensitiveTypesResponse> handler)
        Patches one or more sensitive types in a sensitive type group.

        You can use this operation to add or remove sensitive type ids in a sensitive type group.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • patchMaskingColumns

        Future<PatchMaskingColumnsResponse> patchMaskingColumns​(PatchMaskingColumnsRequest request,
                                                        AsyncHandler<PatchMaskingColumnsRequest,​PatchMaskingColumnsResponse> handler)
        Patches one or more columns in the specified masking policy.

        Use it to create, or update masking columns. To create masking columns, use CreateMaskingColumnDetails as the patch value. And to update masking columns, use UpdateMaskingColumnDetails as the patch value.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • patchSensitiveColumns

        Future<PatchSensitiveColumnsResponse> patchSensitiveColumns​(PatchSensitiveColumnsRequest request,
                                                            AsyncHandler<PatchSensitiveColumnsRequest,​PatchSensitiveColumnsResponse> handler)
        Patches one or more columns in the specified sensitive data model.

        Use it to create, update, or delete sensitive columns. To create sensitive columns, use CreateSensitiveColumnDetails as the patch value. And to update sensitive columns, use UpdateSensitiveColumnDetails as the patch value.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • patchSqlFirewallAllowedSql

        Future<PatchSqlFirewallAllowedSqlResponse> patchSqlFirewallAllowedSql​(PatchSqlFirewallAllowedSqlRequest request,
                                                                      AsyncHandler<PatchSqlFirewallAllowedSqlRequest,​PatchSqlFirewallAllowedSqlResponse> handler)
        Delete multiple allowed sqls.

        You can use this operation to delete one or more allowed sqls. Create and update of multiple allowed sqls is not supported.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • provisionAuditPolicy

        Future<ProvisionAuditPolicyResponse> provisionAuditPolicy​(ProvisionAuditPolicyRequest request,
                                                          AsyncHandler<ProvisionAuditPolicyRequest,​ProvisionAuditPolicyResponse> handler)
        Provision audit policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • purgeSqlCollectionLogs

        Future<PurgeSqlCollectionLogsResponse> purgeSqlCollectionLogs​(PurgeSqlCollectionLogsRequest request,
                                                              AsyncHandler<PurgeSqlCollectionLogsRequest,​PurgeSqlCollectionLogsResponse> handler)
        Purge the SQL collection logs for the specified SqlCollection.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • refreshSecurityAssessment

        Future<RefreshSecurityAssessmentResponse> refreshSecurityAssessment​(RefreshSecurityAssessmentRequest request,
                                                                    AsyncHandler<RefreshSecurityAssessmentRequest,​RefreshSecurityAssessmentResponse> handler)
        Runs a security assessment, refreshes the latest assessment, and saves it for future reference.

        The assessment runs with a securityAssessmentId of type LATEST. Before you start, first call the ListSecurityAssessments operation with filter "type = latest" to get the security assessment id for the target’s latest assessment.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • refreshTargetDatabase

        Future<RefreshTargetDatabaseResponse> refreshTargetDatabase​(RefreshTargetDatabaseRequest request,
                                                            AsyncHandler<RefreshTargetDatabaseRequest,​RefreshTargetDatabaseResponse> handler)
        Refreshes the Data Safe target database to update it’s state.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • refreshUserAssessment

        Future<RefreshUserAssessmentResponse> refreshUserAssessment​(RefreshUserAssessmentRequest request,
                                                            AsyncHandler<RefreshUserAssessmentRequest,​RefreshUserAssessmentResponse> handler)
        Refreshes the latest assessment and saves it for future reference.

        This operation runs with a userAssessmentId of type LATEST. Before you start, first call the ListUserAssessments operation with filter "type = latest" to get the user assessment ID for the target’s latest assessment.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • removeScheduleReport

        Future<RemoveScheduleReportResponse> removeScheduleReport​(RemoveScheduleReportRequest request,
                                                          AsyncHandler<RemoveScheduleReportRequest,​RemoveScheduleReportResponse> handler)
        Deletes the schedule of a .xls or .pdf report.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • resumeAuditTrail

        Future<ResumeAuditTrailResponse> resumeAuditTrail​(ResumeAuditTrailRequest request,
                                                  AsyncHandler<ResumeAuditTrailRequest,​ResumeAuditTrailResponse> handler)
        Resumes the specified audit trail once it got stopped.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • resumeWorkRequest

        Future<ResumeWorkRequestResponse> resumeWorkRequest​(ResumeWorkRequestRequest request,
                                                    AsyncHandler<ResumeWorkRequestRequest,​ResumeWorkRequestResponse> handler)
        Resume the given work request.

        Issuing a resume does not guarantee of immediate resume of the work request.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • retrieveAuditPolicies

        Future<RetrieveAuditPoliciesResponse> retrieveAuditPolicies​(RetrieveAuditPoliciesRequest request,
                                                            AsyncHandler<RetrieveAuditPoliciesRequest,​RetrieveAuditPoliciesResponse> handler)
        Retrieves the audit policy details from the source target database.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • scheduleReport

        Future<ScheduleReportResponse> scheduleReport​(ScheduleReportRequest request,
                                              AsyncHandler<ScheduleReportRequest,​ScheduleReportResponse> handler)
        Schedules a .xls or .pdf report based on parameters and report definition.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • setSecurityAssessmentBaseline

        Future<SetSecurityAssessmentBaselineResponse> setSecurityAssessmentBaseline​(SetSecurityAssessmentBaselineRequest request,
                                                                            AsyncHandler<SetSecurityAssessmentBaselineRequest,​SetSecurityAssessmentBaselineResponse> handler)
        Sets the saved security assessment as the baseline in the compartment where the the specified assessment resides.

        The security assessment needs to be of type ‘SAVED’.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • setUserAssessmentBaseline

        Future<SetUserAssessmentBaselineResponse> setUserAssessmentBaseline​(SetUserAssessmentBaselineRequest request,
                                                                    AsyncHandler<SetUserAssessmentBaselineRequest,​SetUserAssessmentBaselineResponse> handler)
        Sets the saved user assessment as the baseline in the compartment where the specified assessment resides.

        The user assessment needs to be of type ‘SAVED’.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • startAuditTrail

        Future<StartAuditTrailResponse> startAuditTrail​(StartAuditTrailRequest request,
                                                AsyncHandler<StartAuditTrailRequest,​StartAuditTrailResponse> handler)
        Starts collection of audit records on the specified audit trail.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • startSqlCollection

        Future<StartSqlCollectionResponse> startSqlCollection​(StartSqlCollectionRequest request,
                                                      AsyncHandler<StartSqlCollectionRequest,​StartSqlCollectionResponse> handler)
        Start the specified SQL collection.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • stopAuditTrail

        Future<StopAuditTrailResponse> stopAuditTrail​(StopAuditTrailRequest request,
                                              AsyncHandler<StopAuditTrailRequest,​StopAuditTrailResponse> handler)
        Stops the specified audit trail.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • stopSqlCollection

        Future<StopSqlCollectionResponse> stopSqlCollection​(StopSqlCollectionRequest request,
                                                    AsyncHandler<StopSqlCollectionRequest,​StopSqlCollectionResponse> handler)
        Stops the specified SQL collection.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • suspendWorkRequest

        Future<SuspendWorkRequestResponse> suspendWorkRequest​(SuspendWorkRequestRequest request,
                                                      AsyncHandler<SuspendWorkRequestRequest,​SuspendWorkRequestResponse> handler)
        Suspend the given work request.

        Issuing a suspend does not guarantee of a immediate suspend of the work request.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • unsetSecurityAssessmentBaseline

        Future<UnsetSecurityAssessmentBaselineResponse> unsetSecurityAssessmentBaseline​(UnsetSecurityAssessmentBaselineRequest request,
                                                                                AsyncHandler<UnsetSecurityAssessmentBaselineRequest,​UnsetSecurityAssessmentBaselineResponse> handler)
        Removes the baseline setting for the saved security assessment associated with the targetId passed via body.

        If no body or empty body is passed then the baseline settings of all the saved security assessments pertaining to the baseline assessment OCID provided in the path will be removed. Sets the if-match parameter to the value of the etag from a previous GET or POST response for that resource.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • unsetUserAssessmentBaseline

        Future<UnsetUserAssessmentBaselineResponse> unsetUserAssessmentBaseline​(UnsetUserAssessmentBaselineRequest request,
                                                                        AsyncHandler<UnsetUserAssessmentBaselineRequest,​UnsetUserAssessmentBaselineResponse> handler)
        Removes the baseline setting for the saved user assessment associated with the targetId passed via body.

        If no body or empty body is passed then the baseline settings of all the saved user assessments pertaining to the baseline assessment OCID provided in the path will be removed. Sets the if-match parameter to the value of the etag from a previous GET or POST response for that resource.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateAlert

        Future<UpdateAlertResponse> updateAlert​(UpdateAlertRequest request,
                                        AsyncHandler<UpdateAlertRequest,​UpdateAlertResponse> handler)
        Updates the status of the specified alert.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateAlertPolicy

        Future<UpdateAlertPolicyResponse> updateAlertPolicy​(UpdateAlertPolicyRequest request,
                                                    AsyncHandler<UpdateAlertPolicyRequest,​UpdateAlertPolicyResponse> handler)
        Updates the specified alert policy .
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateAlertPolicyRule

        Future<UpdateAlertPolicyRuleResponse> updateAlertPolicyRule​(UpdateAlertPolicyRuleRequest request,
                                                            AsyncHandler<UpdateAlertPolicyRuleRequest,​UpdateAlertPolicyRuleResponse> handler)
        Updates the specified alert policy rule.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateAttributeSet

        Future<UpdateAttributeSetResponse> updateAttributeSet​(UpdateAttributeSetRequest request,
                                                      AsyncHandler<UpdateAttributeSetRequest,​UpdateAttributeSetResponse> handler)
        Updates an attribute set.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateAuditPolicy

        Future<UpdateAuditPolicyResponse> updateAuditPolicy​(UpdateAuditPolicyRequest request,
                                                    AsyncHandler<UpdateAuditPolicyRequest,​UpdateAuditPolicyResponse> handler)
        Updates the audit policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateAuditProfile

        Future<UpdateAuditProfileResponse> updateAuditProfile​(UpdateAuditProfileRequest request,
                                                      AsyncHandler<UpdateAuditProfileRequest,​UpdateAuditProfileResponse> handler)
        Updates one or more attributes of the specified audit profile.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateAuditTrail

        Future<UpdateAuditTrailResponse> updateAuditTrail​(UpdateAuditTrailRequest request,
                                                  AsyncHandler<UpdateAuditTrailRequest,​UpdateAuditTrailResponse> handler)
        Updates one or more attributes of the specified audit trail.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateFinding

        Future<UpdateFindingResponse> updateFinding​(UpdateFindingRequest request,
                                            AsyncHandler<UpdateFindingRequest,​UpdateFindingResponse> handler)
        Updates one or more attributes of the specified finding.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateLibraryMaskingFormat

        Future<UpdateLibraryMaskingFormatResponse> updateLibraryMaskingFormat​(UpdateLibraryMaskingFormatRequest request,
                                                                      AsyncHandler<UpdateLibraryMaskingFormatRequest,​UpdateLibraryMaskingFormatResponse> handler)
        Updates one or more attributes of the specified library masking format.

        Note that updating the formatEntries attribute replaces all the existing masking format entries with the specified format entries.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateMaskingColumn

        Future<UpdateMaskingColumnResponse> updateMaskingColumn​(UpdateMaskingColumnRequest request,
                                                        AsyncHandler<UpdateMaskingColumnRequest,​UpdateMaskingColumnResponse> handler)
        Updates one or more attributes of the specified masking column.

        Note that updating the maskingFormats attribute replaces the currently assigned masking formats with the specified masking formats.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateMaskingPolicy

        Future<UpdateMaskingPolicyResponse> updateMaskingPolicy​(UpdateMaskingPolicyRequest request,
                                                        AsyncHandler<UpdateMaskingPolicyRequest,​UpdateMaskingPolicyResponse> handler)
        Updates one or more attributes of the specified masking policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateOnPremConnector

        Future<UpdateOnPremConnectorResponse> updateOnPremConnector​(UpdateOnPremConnectorRequest request,
                                                            AsyncHandler<UpdateOnPremConnectorRequest,​UpdateOnPremConnectorResponse> handler)
        Updates one or more attributes of the specified on-premises connector.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updatePeerTargetDatabase

        Future<UpdatePeerTargetDatabaseResponse> updatePeerTargetDatabase​(UpdatePeerTargetDatabaseRequest request,
                                                                  AsyncHandler<UpdatePeerTargetDatabaseRequest,​UpdatePeerTargetDatabaseResponse> handler)
        Updates one or more attributes of the specified Data Safe peer target database.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateReport

        Future<UpdateReportResponse> updateReport​(UpdateReportRequest request,
                                          AsyncHandler<UpdateReportRequest,​UpdateReportResponse> handler)
        Updates the specified report.

        Only tags can be updated.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateReportDefinition

        Future<UpdateReportDefinitionResponse> updateReportDefinition​(UpdateReportDefinitionRequest request,
                                                              AsyncHandler<UpdateReportDefinitionRequest,​UpdateReportDefinitionResponse> handler)
        Updates the specified report definition.

        Only user created report definition can be updated. Seeded report definitions need to be saved as new report definition first.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateSecurityAssessment

        Future<UpdateSecurityAssessmentResponse> updateSecurityAssessment​(UpdateSecurityAssessmentRequest request,
                                                                  AsyncHandler<UpdateSecurityAssessmentRequest,​UpdateSecurityAssessmentResponse> handler)
        Updates one or more attributes of the specified security assessment.

        This operation allows to update the security assessment displayName, description, or schedule.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateSecurityPolicy

        Future<UpdateSecurityPolicyResponse> updateSecurityPolicy​(UpdateSecurityPolicyRequest request,
                                                          AsyncHandler<UpdateSecurityPolicyRequest,​UpdateSecurityPolicyResponse> handler)
        Updates the security policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateSensitiveColumn

        Future<UpdateSensitiveColumnResponse> updateSensitiveColumn​(UpdateSensitiveColumnRequest request,
                                                            AsyncHandler<UpdateSensitiveColumnRequest,​UpdateSensitiveColumnResponse> handler)
        Updates one or more attributes of the specified sensitive column.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateSensitiveDataModel

        Future<UpdateSensitiveDataModelResponse> updateSensitiveDataModel​(UpdateSensitiveDataModelRequest request,
                                                                  AsyncHandler<UpdateSensitiveDataModelRequest,​UpdateSensitiveDataModelResponse> handler)
        Updates one or more attributes of the specified sensitive data model.

        Note that updating any attribute of a sensitive data model does not perform data discovery.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateSensitiveType

        Future<UpdateSensitiveTypeResponse> updateSensitiveType​(UpdateSensitiveTypeRequest request,
                                                        AsyncHandler<UpdateSensitiveTypeRequest,​UpdateSensitiveTypeResponse> handler)
        Updates one or more attributes of the specified sensitive type.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateSensitiveTypeGroup

        Future<UpdateSensitiveTypeGroupResponse> updateSensitiveTypeGroup​(UpdateSensitiveTypeGroupRequest request,
                                                                  AsyncHandler<UpdateSensitiveTypeGroupRequest,​UpdateSensitiveTypeGroupResponse> handler)
        Updates one or more attributes of the specified sensitive type group.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateSqlCollection

        Future<UpdateSqlCollectionResponse> updateSqlCollection​(UpdateSqlCollectionRequest request,
                                                        AsyncHandler<UpdateSqlCollectionRequest,​UpdateSqlCollectionResponse> handler)
        Updates the SQL collection.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateTargetDatabase

        Future<UpdateTargetDatabaseResponse> updateTargetDatabase​(UpdateTargetDatabaseRequest request,
                                                          AsyncHandler<UpdateTargetDatabaseRequest,​UpdateTargetDatabaseResponse> handler)
        Updates one or more attributes of the specified Data Safe target database.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateUserAssessment

        Future<UpdateUserAssessmentResponse> updateUserAssessment​(UpdateUserAssessmentRequest request,
                                                          AsyncHandler<UpdateUserAssessmentRequest,​UpdateUserAssessmentResponse> handler)
        Updates one or more attributes of the specified user assessment.

        This operation allows to update the user assessment displayName, description, or schedule.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • uploadMaskingPolicy

        Future<UploadMaskingPolicyResponse> uploadMaskingPolicy​(UploadMaskingPolicyRequest request,
                                                        AsyncHandler<UploadMaskingPolicyRequest,​UploadMaskingPolicyResponse> handler)
        Uploads a masking policy file (also called template) to update the specified masking policy.

        To create a new masking policy using a file, first use the CreateMaskingPolicy operation to create an empty masking policy and then use this endpoint to upload the masking policy file. Note that the upload operation replaces the content of the specified masking policy, including all the existing columns and masking formats, with the content of the file.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • uploadSensitiveDataModel

        Future<UploadSensitiveDataModelResponse> uploadSensitiveDataModel​(UploadSensitiveDataModelRequest request,
                                                                  AsyncHandler<UploadSensitiveDataModelRequest,​UploadSensitiveDataModelResponse> handler)
        Uploads a sensitive data model file (also called template) to update the specified sensitive data model.

        To create a new sensitive data model using a file, first use the CreateSensitiveDataModel operation to create an empty data model and then use this endpoint to upload the data model file. Note that the upload operation replaces the content of the specified sensitive data model, including all the existing columns and their relationships, with the content of the file.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.