Class DataSafeAsyncClient

  • All Implemented Interfaces:
    DataSafeAsync, AutoCloseable

    @Generated(value="OracleSDKGenerator",
               comments="API Version: 20181201")
    public class DataSafeAsyncClient
    extends BaseAsyncClient
    implements DataSafeAsync
    Async client implementation for DataSafe service.
    There are two ways to use async client: 1. Use AsyncHandler: using AsyncHandler, if the response to the call is an InputStream, like getObject Api in object storage service, developers need to process the stream in AsyncHandler, and not anywhere else, because the stream will be closed right after the AsyncHandler is invoked.
    2. Use Java Future: using Java Future, developers need to close the stream after they are done with the Java Future.
    Accessing the result should be done in a mutually exclusive manner, either through the Future or the AsyncHandler, but not both. If the Future is used, the caller should pass in null as the AsyncHandler. If the AsyncHandler is used, it is still safe to use the Future to determine whether or not the request was completed via Future.isDone/isCancelled.
    Please refer to https://github.com/oracle/oci-java-sdk/blob/master/bmc-examples/src/main/java/ResteasyClientWithObjectStorageExample.java
    • Field Detail

      • SERVICE

        public static final Service SERVICE
        Service instance for DataSafe.
      • clientCommonLibraryVersion

        public final String clientCommonLibraryVersion
        Compatible SDK version, provided by the codegen.
      • minimumClientCommonLibraryVersionFromClient

        public final Optional<String> minimumClientCommonLibraryVersionFromClient
        Minimum compatible SDK version, maybe provided by the codegen.
    • Method Detail

      • setRegion

        public void setRegion​(Region region)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        setRegion in interface DataSafeAsync
        Parameters:
        region - The region of the service.
      • addMaskingColumnsFromSdm

        public Future<AddMaskingColumnsFromSdmResponse> addMaskingColumnsFromSdm​(AddMaskingColumnsFromSdmRequest request,
                                                                                 AsyncHandler<AddMaskingColumnsFromSdmRequest,​AddMaskingColumnsFromSdmResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        addMaskingColumnsFromSdm in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<AlertsUpdateResponse> alertsUpdate​(AlertsUpdateRequest request,
                                                         AsyncHandler<AlertsUpdateRequest,​AlertsUpdateResponse> handler)
        Description copied from interface: DataSafeAsync
        Updates alerts in the specified compartment.
        Specified by:
        alertsUpdate in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ApplyDiscoveryJobResultsResponse> applyDiscoveryJobResults​(ApplyDiscoveryJobResultsRequest request,
                                                                                 AsyncHandler<ApplyDiscoveryJobResultsRequest,​ApplyDiscoveryJobResultsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        applyDiscoveryJobResults in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ApplySdmMaskingPolicyDifferenceResponse> applySdmMaskingPolicyDifference​(ApplySdmMaskingPolicyDifferenceRequest request,
                                                                                               AsyncHandler<ApplySdmMaskingPolicyDifferenceRequest,​ApplySdmMaskingPolicyDifferenceResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        applySdmMaskingPolicyDifference in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ChangeRetentionResponse> changeRetention​(ChangeRetentionRequest request,
                                                               AsyncHandler<ChangeRetentionRequest,​ChangeRetentionResponse> handler)
        Description copied from interface: DataSafeAsync
        Change the online and offline months .
        Specified by:
        changeRetention in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ChangeSecurityAssessmentCompartmentResponse> changeSecurityAssessmentCompartment​(ChangeSecurityAssessmentCompartmentRequest request,
                                                                                                       AsyncHandler<ChangeSecurityAssessmentCompartmentRequest,​ChangeSecurityAssessmentCompartmentResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        changeSecurityAssessmentCompartment in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ChangeUserAssessmentCompartmentResponse> changeUserAssessmentCompartment​(ChangeUserAssessmentCompartmentRequest request,
                                                                                               AsyncHandler<ChangeUserAssessmentCompartmentRequest,​ChangeUserAssessmentCompartmentResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        changeUserAssessmentCompartment in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<CompareSecurityAssessmentResponse> compareSecurityAssessment​(CompareSecurityAssessmentRequest request,
                                                                                   AsyncHandler<CompareSecurityAssessmentRequest,​CompareSecurityAssessmentResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        compareSecurityAssessment in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<CompareUserAssessmentResponse> compareUserAssessment​(CompareUserAssessmentRequest request,
                                                                           AsyncHandler<CompareUserAssessmentRequest,​CompareUserAssessmentResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        compareUserAssessment in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<CreateAuditArchiveRetrievalResponse> createAuditArchiveRetrieval​(CreateAuditArchiveRetrievalRequest request,
                                                                                       AsyncHandler<CreateAuditArchiveRetrievalRequest,​CreateAuditArchiveRetrievalResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        createAuditArchiveRetrieval in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<CreateDiscoveryJobResponse> createDiscoveryJob​(CreateDiscoveryJobRequest request,
                                                                     AsyncHandler<CreateDiscoveryJobRequest,​CreateDiscoveryJobResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        createDiscoveryJob in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<CreateLibraryMaskingFormatResponse> createLibraryMaskingFormat​(CreateLibraryMaskingFormatRequest request,
                                                                                     AsyncHandler<CreateLibraryMaskingFormatRequest,​CreateLibraryMaskingFormatResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        createLibraryMaskingFormat in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<CreateMaskingColumnResponse> createMaskingColumn​(CreateMaskingColumnRequest request,
                                                                       AsyncHandler<CreateMaskingColumnRequest,​CreateMaskingColumnResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        createMaskingColumn in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<CreateMaskingPolicyResponse> createMaskingPolicy​(CreateMaskingPolicyRequest request,
                                                                       AsyncHandler<CreateMaskingPolicyRequest,​CreateMaskingPolicyResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        createMaskingPolicy in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<CreateSdmMaskingPolicyDifferenceResponse> createSdmMaskingPolicyDifference​(CreateSdmMaskingPolicyDifferenceRequest request,
                                                                                                 AsyncHandler<CreateSdmMaskingPolicyDifferenceRequest,​CreateSdmMaskingPolicyDifferenceResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        createSdmMaskingPolicyDifference in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<CreateSecurityAssessmentResponse> createSecurityAssessment​(CreateSecurityAssessmentRequest request,
                                                                                 AsyncHandler<CreateSecurityAssessmentRequest,​CreateSecurityAssessmentResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        createSecurityAssessment in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<CreateSensitiveDataModelResponse> createSensitiveDataModel​(CreateSensitiveDataModelRequest request,
                                                                                 AsyncHandler<CreateSensitiveDataModelRequest,​CreateSensitiveDataModelResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        createSensitiveDataModel in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<CreateSensitiveTypeResponse> createSensitiveType​(CreateSensitiveTypeRequest request,
                                                                       AsyncHandler<CreateSensitiveTypeRequest,​CreateSensitiveTypeResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        createSensitiveType in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<CreateSensitiveTypesExportResponse> createSensitiveTypesExport​(CreateSensitiveTypesExportRequest request,
                                                                                     AsyncHandler<CreateSensitiveTypesExportRequest,​CreateSensitiveTypesExportResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        createSensitiveTypesExport in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<CreateTargetDatabaseResponse> createTargetDatabase​(CreateTargetDatabaseRequest request,
                                                                         AsyncHandler<CreateTargetDatabaseRequest,​CreateTargetDatabaseResponse> handler)
        Description copied from interface: DataSafeAsync
        Registers the specified database with Data Safe and creates a Data Safe target database in the Data Safe Console.
        Specified by:
        createTargetDatabase in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<CreateUserAssessmentResponse> createUserAssessment​(CreateUserAssessmentRequest request,
                                                                         AsyncHandler<CreateUserAssessmentRequest,​CreateUserAssessmentResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        createUserAssessment in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<DeleteSecurityAssessmentResponse> deleteSecurityAssessment​(DeleteSecurityAssessmentRequest request,
                                                                                 AsyncHandler<DeleteSecurityAssessmentRequest,​DeleteSecurityAssessmentResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        deleteSecurityAssessment in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<DeleteTargetDatabaseResponse> deleteTargetDatabase​(DeleteTargetDatabaseRequest request,
                                                                         AsyncHandler<DeleteTargetDatabaseRequest,​DeleteTargetDatabaseResponse> handler)
        Description copied from interface: DataSafeAsync
        Deregisters the specified database from Data Safe and removes the target database from the Data Safe Console.
        Specified by:
        deleteTargetDatabase in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<DeleteUserAssessmentResponse> deleteUserAssessment​(DeleteUserAssessmentRequest request,
                                                                         AsyncHandler<DeleteUserAssessmentRequest,​DeleteUserAssessmentResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        deleteUserAssessment in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<DiscoverAuditTrailsResponse> discoverAuditTrails​(DiscoverAuditTrailsRequest request,
                                                                       AsyncHandler<DiscoverAuditTrailsRequest,​DiscoverAuditTrailsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.
        Specified by:
        discoverAuditTrails in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<DownloadDiscoveryReportResponse> downloadDiscoveryReport​(DownloadDiscoveryReportRequest request,
                                                                               AsyncHandler<DownloadDiscoveryReportRequest,​DownloadDiscoveryReportResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        downloadDiscoveryReport in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<DownloadMaskingLogResponse> downloadMaskingLog​(DownloadMaskingLogRequest request,
                                                                     AsyncHandler<DownloadMaskingLogRequest,​DownloadMaskingLogResponse> handler)
        Description copied from interface: DataSafeAsync
        Downloads the masking log generated by the last masking operation on a target database using the specified masking policy.
        Specified by:
        downloadMaskingLog in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<DownloadMaskingPolicyResponse> downloadMaskingPolicy​(DownloadMaskingPolicyRequest request,
                                                                           AsyncHandler<DownloadMaskingPolicyRequest,​DownloadMaskingPolicyResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        downloadMaskingPolicy in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<DownloadMaskingReportResponse> downloadMaskingReport​(DownloadMaskingReportRequest request,
                                                                           AsyncHandler<DownloadMaskingReportRequest,​DownloadMaskingReportResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        downloadMaskingReport in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<DownloadSensitiveDataModelResponse> downloadSensitiveDataModel​(DownloadSensitiveDataModelRequest request,
                                                                                     AsyncHandler<DownloadSensitiveDataModelRequest,​DownloadSensitiveDataModelResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        downloadSensitiveDataModel in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GenerateDiscoveryReportForDownloadResponse> generateDiscoveryReportForDownload​(GenerateDiscoveryReportForDownloadRequest request,
                                                                                                     AsyncHandler<GenerateDiscoveryReportForDownloadRequest,​GenerateDiscoveryReportForDownloadResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        generateDiscoveryReportForDownload in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GenerateMaskingPolicyForDownloadResponse> generateMaskingPolicyForDownload​(GenerateMaskingPolicyForDownloadRequest request,
                                                                                                 AsyncHandler<GenerateMaskingPolicyForDownloadRequest,​GenerateMaskingPolicyForDownloadResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        generateMaskingPolicyForDownload in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GenerateReportResponse> generateReport​(GenerateReportRequest request,
                                                             AsyncHandler<GenerateReportRequest,​GenerateReportResponse> handler)
        Description copied from interface: DataSafeAsync
        Generates a .xls or .pdf report based on parameters and report definition.
        Specified by:
        generateReport in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GenerateSensitiveDataModelForDownloadResponse> generateSensitiveDataModelForDownload​(GenerateSensitiveDataModelForDownloadRequest request,
                                                                                                           AsyncHandler<GenerateSensitiveDataModelForDownloadRequest,​GenerateSensitiveDataModelForDownloadResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        generateSensitiveDataModelForDownload in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GetAlertResponse> getAlert​(GetAlertRequest request,
                                                 AsyncHandler<GetAlertRequest,​GetAlertResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets the details of the specified alerts.
        Specified by:
        getAlert in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GetAlertPolicyResponse> getAlertPolicy​(GetAlertPolicyRequest request,
                                                             AsyncHandler<GetAlertPolicyRequest,​GetAlertPolicyResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets the details of alert policy by its ID.
        Specified by:
        getAlertPolicy in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GetAuditPolicyResponse> getAuditPolicy​(GetAuditPolicyRequest request,
                                                             AsyncHandler<GetAuditPolicyRequest,​GetAuditPolicyResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets a audit policy by identifier.
        Specified by:
        getAuditPolicy in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GetAuditProfileResponse> getAuditProfile​(GetAuditProfileRequest request,
                                                               AsyncHandler<GetAuditProfileRequest,​GetAuditProfileResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets the details of audit profile resource and associated audit trails of the audit profile.
        Specified by:
        getAuditProfile in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GetAuditTrailResponse> getAuditTrail​(GetAuditTrailRequest request,
                                                           AsyncHandler<GetAuditTrailRequest,​GetAuditTrailResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets the details of audit trail.
        Specified by:
        getAuditTrail in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GetCompatibleFormatsForDataTypesResponse> getCompatibleFormatsForDataTypes​(GetCompatibleFormatsForDataTypesRequest request,
                                                                                                 AsyncHandler<GetCompatibleFormatsForDataTypesRequest,​GetCompatibleFormatsForDataTypesResponse> handler)
        Description copied from interface: DataSafeAsync
        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

        Specified by:
        getCompatibleFormatsForDataTypes in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GetDiscoveryJobResponse> getDiscoveryJob​(GetDiscoveryJobRequest request,
                                                               AsyncHandler<GetDiscoveryJobRequest,​GetDiscoveryJobResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets the details of the specified discovery job.
        Specified by:
        getDiscoveryJob in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GetMaskingColumnResponse> getMaskingColumn​(GetMaskingColumnRequest request,
                                                                 AsyncHandler<GetMaskingColumnRequest,​GetMaskingColumnResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets the details of the specified masking column.
        Specified by:
        getMaskingColumn in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GetMaskingPolicyResponse> getMaskingPolicy​(GetMaskingPolicyRequest request,
                                                                 AsyncHandler<GetMaskingPolicyRequest,​GetMaskingPolicyResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets the details of the specified masking policy.
        Specified by:
        getMaskingPolicy in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GetMaskingReportResponse> getMaskingReport​(GetMaskingReportRequest request,
                                                                 AsyncHandler<GetMaskingReportRequest,​GetMaskingReportResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets the details of the specified masking report.
        Specified by:
        getMaskingReport in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GetProfileResponse> getProfile​(GetProfileRequest request,
                                                     AsyncHandler<GetProfileRequest,​GetProfileResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        getProfile in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GetReportResponse> getReport​(GetReportRequest request,
                                                   AsyncHandler<GetReportRequest,​GetReportResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets a report by identifier
        Specified by:
        getReport in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GetReportContentResponse> getReportContent​(GetReportContentRequest request,
                                                                 AsyncHandler<GetReportContentRequest,​GetReportContentResponse> handler)
        Description copied from interface: DataSafeAsync
        Downloads the specified report in the form of .xls or .pdf.
        Specified by:
        getReportContent in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GetSecurityPolicyResponse> getSecurityPolicy​(GetSecurityPolicyRequest request,
                                                                   AsyncHandler<GetSecurityPolicyRequest,​GetSecurityPolicyResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets a security policy by the specified OCID of the security policy resource.
        Specified by:
        getSecurityPolicy in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GetSensitiveTypeResponse> getSensitiveType​(GetSensitiveTypeRequest request,
                                                                 AsyncHandler<GetSensitiveTypeRequest,​GetSensitiveTypeResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets the details of the specified sensitive type.
        Specified by:
        getSensitiveType in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GetTargetDatabaseResponse> getTargetDatabase​(GetTargetDatabaseRequest request,
                                                                   AsyncHandler<GetTargetDatabaseRequest,​GetTargetDatabaseResponse> handler)
        Description copied from interface: DataSafeAsync
        Returns the details of the specified Data Safe target database.
        Specified by:
        getTargetDatabase in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<GetWorkRequestResponse> getWorkRequest​(GetWorkRequestRequest request,
                                                             AsyncHandler<GetWorkRequestRequest,​GetWorkRequestResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets the details of the specified work request.
        Specified by:
        getWorkRequest in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListAlertPolicyRulesResponse> listAlertPolicyRules​(ListAlertPolicyRulesRequest request,
                                                                         AsyncHandler<ListAlertPolicyRulesRequest,​ListAlertPolicyRulesResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listAlertPolicyRules in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListAlertsResponse> listAlerts​(ListAlertsRequest request,
                                                     AsyncHandler<ListAlertsRequest,​ListAlertsResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets a list of all alerts.
        Specified by:
        listAlerts in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListAuditEventAnalyticsResponse> listAuditEventAnalytics​(ListAuditEventAnalyticsRequest request,
                                                                               AsyncHandler<ListAuditEventAnalyticsRequest,​ListAuditEventAnalyticsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listAuditEventAnalytics in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListAuditEventsResponse> listAuditEvents​(ListAuditEventsRequest request,
                                                               AsyncHandler<ListAuditEventsRequest,​ListAuditEventsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listAuditEvents in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListAuditPoliciesResponse> listAuditPolicies​(ListAuditPoliciesRequest request,
                                                                   AsyncHandler<ListAuditPoliciesRequest,​ListAuditPoliciesResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listAuditPolicies in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListAuditPolicyAnalyticsResponse> listAuditPolicyAnalytics​(ListAuditPolicyAnalyticsRequest request,
                                                                                 AsyncHandler<ListAuditPolicyAnalyticsRequest,​ListAuditPolicyAnalyticsResponse> handler)
        Description copied from interface: DataSafeAsync
        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

        Specified by:
        listAuditPolicyAnalytics in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListAuditProfileAnalyticsResponse> listAuditProfileAnalytics​(ListAuditProfileAnalyticsRequest request,
                                                                                   AsyncHandler<ListAuditProfileAnalyticsRequest,​ListAuditProfileAnalyticsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listAuditProfileAnalytics in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListAuditProfilesResponse> listAuditProfiles​(ListAuditProfilesRequest request,
                                                                   AsyncHandler<ListAuditProfilesRequest,​ListAuditProfilesResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listAuditProfiles in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListAuditTrailAnalyticsResponse> listAuditTrailAnalytics​(ListAuditTrailAnalyticsRequest request,
                                                                               AsyncHandler<ListAuditTrailAnalyticsRequest,​ListAuditTrailAnalyticsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listAuditTrailAnalytics in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListAuditTrailsResponse> listAuditTrails​(ListAuditTrailsRequest request,
                                                               AsyncHandler<ListAuditTrailsRequest,​ListAuditTrailsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listAuditTrails in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListColumnsResponse> listColumns​(ListColumnsRequest request,
                                                       AsyncHandler<ListColumnsRequest,​ListColumnsResponse> handler)
        Description copied from interface: DataSafeAsync
        Returns a list of column metadata objects.
        Specified by:
        listColumns in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListDatabaseSecurityConfigsResponse> listDatabaseSecurityConfigs​(ListDatabaseSecurityConfigsRequest request,
                                                                                       AsyncHandler<ListDatabaseSecurityConfigsRequest,​ListDatabaseSecurityConfigsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listDatabaseSecurityConfigs in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListDiscoveryAnalyticsResponse> listDiscoveryAnalytics​(ListDiscoveryAnalyticsRequest request,
                                                                             AsyncHandler<ListDiscoveryAnalyticsRequest,​ListDiscoveryAnalyticsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listDiscoveryAnalytics in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListDiscoveryJobsResponse> listDiscoveryJobs​(ListDiscoveryJobsRequest request,
                                                                   AsyncHandler<ListDiscoveryJobsRequest,​ListDiscoveryJobsResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets a list of incremental discovery jobs based on the specified query parameters.
        Specified by:
        listDiscoveryJobs in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListFindingAnalyticsResponse> listFindingAnalytics​(ListFindingAnalyticsRequest request,
                                                                         AsyncHandler<ListFindingAnalyticsRequest,​ListFindingAnalyticsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listFindingAnalytics in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListFindingsResponse> listFindings​(ListFindingsRequest request,
                                                         AsyncHandler<ListFindingsRequest,​ListFindingsResponse> handler)
        Description copied from interface: DataSafeAsync
        List all the findings from all the targets in the specified compartment.
        Specified by:
        listFindings in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListGrantsResponse> listGrants​(ListGrantsRequest request,
                                                     AsyncHandler<ListGrantsRequest,​ListGrantsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listGrants in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListMaskedColumnsResponse> listMaskedColumns​(ListMaskedColumnsRequest request,
                                                                   AsyncHandler<ListMaskedColumnsRequest,​ListMaskedColumnsResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets a list of masked columns present in the specified masking report and based on the specified query parameters.
        Specified by:
        listMaskedColumns in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListMaskingAnalyticsResponse> listMaskingAnalytics​(ListMaskingAnalyticsRequest request,
                                                                         AsyncHandler<ListMaskingAnalyticsRequest,​ListMaskingAnalyticsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listMaskingAnalytics in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListMaskingColumnsResponse> listMaskingColumns​(ListMaskingColumnsRequest request,
                                                                     AsyncHandler<ListMaskingColumnsRequest,​ListMaskingColumnsResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets a list of masking columns present in the specified masking policy and based on the specified query parameters.
        Specified by:
        listMaskingColumns in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListMaskingErrorsResponse> listMaskingErrors​(ListMaskingErrorsRequest request,
                                                                   AsyncHandler<ListMaskingErrorsRequest,​ListMaskingErrorsResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets a list of masking errors in a masking run based on the specified query parameters.
        Specified by:
        listMaskingErrors in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListMaskingObjectsResponse> listMaskingObjects​(ListMaskingObjectsRequest request,
                                                                     AsyncHandler<ListMaskingObjectsRequest,​ListMaskingObjectsResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets a list of masking objects present in the specified masking policy and based on the specified query parameters.
        Specified by:
        listMaskingObjects in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListMaskingSchemasResponse> listMaskingSchemas​(ListMaskingSchemasRequest request,
                                                                     AsyncHandler<ListMaskingSchemasRequest,​ListMaskingSchemasResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets a list of masking schemas present in the specified masking policy and based on the specified query parameters.
        Specified by:
        listMaskingSchemas in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListPasswordExpiryDateAnalyticsResponse> listPasswordExpiryDateAnalytics​(ListPasswordExpiryDateAnalyticsRequest request,
                                                                                               AsyncHandler<ListPasswordExpiryDateAnalyticsRequest,​ListPasswordExpiryDateAnalyticsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listPasswordExpiryDateAnalytics in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListProfileAnalyticsResponse> listProfileAnalytics​(ListProfileAnalyticsRequest request,
                                                                         AsyncHandler<ListProfileAnalyticsRequest,​ListProfileAnalyticsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listProfileAnalytics in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListProfileSummariesResponse> listProfileSummaries​(ListProfileSummariesRequest request,
                                                                         AsyncHandler<ListProfileSummariesRequest,​ListProfileSummariesResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listProfileSummaries in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListReportDefinitionsResponse> listReportDefinitions​(ListReportDefinitionsRequest request,
                                                                           AsyncHandler<ListReportDefinitionsRequest,​ListReportDefinitionsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listReportDefinitions in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListReportsResponse> listReports​(ListReportsRequest request,
                                                       AsyncHandler<ListReportsRequest,​ListReportsResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets a list of all the reports in the compartment.

        It contains information such as report generation time.

        Specified by:
        listReports in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListRoleGrantPathsResponse> listRoleGrantPaths​(ListRoleGrantPathsRequest request,
                                                                     AsyncHandler<ListRoleGrantPathsRequest,​ListRoleGrantPathsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listRoleGrantPaths in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListRolesResponse> listRoles​(ListRolesRequest request,
                                                   AsyncHandler<ListRolesRequest,​ListRolesResponse> handler)
        Description copied from interface: DataSafeAsync
        Returns a list of role metadata objects.
        Specified by:
        listRoles in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListSchemasResponse> listSchemas​(ListSchemasRequest request,
                                                       AsyncHandler<ListSchemasRequest,​ListSchemasResponse> handler)
        Description copied from interface: DataSafeAsync
        Returns list of schema.
        Specified by:
        listSchemas in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListSecurityAssessmentsResponse> listSecurityAssessments​(ListSecurityAssessmentsRequest request,
                                                                               AsyncHandler<ListSecurityAssessmentsRequest,​ListSecurityAssessmentsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listSecurityAssessments in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListSecurityFeatureAnalyticsResponse> listSecurityFeatureAnalytics​(ListSecurityFeatureAnalyticsRequest request,
                                                                                         AsyncHandler<ListSecurityFeatureAnalyticsRequest,​ListSecurityFeatureAnalyticsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listSecurityFeatureAnalytics in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListSecurityFeaturesResponse> listSecurityFeatures​(ListSecurityFeaturesRequest request,
                                                                         AsyncHandler<ListSecurityFeaturesRequest,​ListSecurityFeaturesResponse> handler)
        Description copied from interface: DataSafeAsync
        Lists the usage of Database security features for a given compartment or a target level, based on the filters provided.
        Specified by:
        listSecurityFeatures in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListSecurityPoliciesResponse> listSecurityPolicies​(ListSecurityPoliciesRequest request,
                                                                         AsyncHandler<ListSecurityPoliciesRequest,​ListSecurityPoliciesResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listSecurityPolicies in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListSecurityPolicyDeploymentsResponse> listSecurityPolicyDeployments​(ListSecurityPolicyDeploymentsRequest request,
                                                                                           AsyncHandler<ListSecurityPolicyDeploymentsRequest,​ListSecurityPolicyDeploymentsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listSecurityPolicyDeployments in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListSecurityPolicyReportsResponse> listSecurityPolicyReports​(ListSecurityPolicyReportsRequest request,
                                                                                   AsyncHandler<ListSecurityPolicyReportsRequest,​ListSecurityPolicyReportsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listSecurityPolicyReports in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListSensitiveColumnAnalyticsResponse> listSensitiveColumnAnalytics​(ListSensitiveColumnAnalyticsRequest request,
                                                                                         AsyncHandler<ListSensitiveColumnAnalyticsRequest,​ListSensitiveColumnAnalyticsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listSensitiveColumnAnalytics in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListSensitiveColumnsResponse> listSensitiveColumns​(ListSensitiveColumnsRequest request,
                                                                         AsyncHandler<ListSensitiveColumnsRequest,​ListSensitiveColumnsResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets a list of sensitive columns present in the specified sensitive data model based on the specified query parameters.
        Specified by:
        listSensitiveColumns in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListSensitiveObjectsResponse> listSensitiveObjects​(ListSensitiveObjectsRequest request,
                                                                         AsyncHandler<ListSensitiveObjectsRequest,​ListSensitiveObjectsResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets a list of sensitive objects present in the specified sensitive data model based on the specified query parameters.
        Specified by:
        listSensitiveObjects in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListSensitiveSchemasResponse> listSensitiveSchemas​(ListSensitiveSchemasRequest request,
                                                                         AsyncHandler<ListSensitiveSchemasRequest,​ListSensitiveSchemasResponse> handler)
        Description copied from interface: DataSafeAsync
        Gets a list of sensitive schemas present in the specified sensitive data model based on the specified query parameters.
        Specified by:
        listSensitiveSchemas in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListSensitiveTypesExportsResponse> listSensitiveTypesExports​(ListSensitiveTypesExportsRequest request,
                                                                                   AsyncHandler<ListSensitiveTypesExportsRequest,​ListSensitiveTypesExportsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listSensitiveTypesExports in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListSqlCollectionAnalyticsResponse> listSqlCollectionAnalytics​(ListSqlCollectionAnalyticsRequest request,
                                                                                     AsyncHandler<ListSqlCollectionAnalyticsRequest,​ListSqlCollectionAnalyticsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listSqlCollectionAnalytics in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListSqlCollectionsResponse> listSqlCollections​(ListSqlCollectionsRequest request,
                                                                     AsyncHandler<ListSqlCollectionsRequest,​ListSqlCollectionsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listSqlCollections in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListSqlFirewallAllowedSqlAnalyticsResponse> listSqlFirewallAllowedSqlAnalytics​(ListSqlFirewallAllowedSqlAnalyticsRequest request,
                                                                                                     AsyncHandler<ListSqlFirewallAllowedSqlAnalyticsRequest,​ListSqlFirewallAllowedSqlAnalyticsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listSqlFirewallAllowedSqlAnalytics in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListSqlFirewallAllowedSqlsResponse> listSqlFirewallAllowedSqls​(ListSqlFirewallAllowedSqlsRequest request,
                                                                                     AsyncHandler<ListSqlFirewallAllowedSqlsRequest,​ListSqlFirewallAllowedSqlsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listSqlFirewallAllowedSqls in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListSqlFirewallPoliciesResponse> listSqlFirewallPolicies​(ListSqlFirewallPoliciesRequest request,
                                                                               AsyncHandler<ListSqlFirewallPoliciesRequest,​ListSqlFirewallPoliciesResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listSqlFirewallPolicies in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListSqlFirewallPolicyAnalyticsResponse> listSqlFirewallPolicyAnalytics​(ListSqlFirewallPolicyAnalyticsRequest request,
                                                                                             AsyncHandler<ListSqlFirewallPolicyAnalyticsRequest,​ListSqlFirewallPolicyAnalyticsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listSqlFirewallPolicyAnalytics in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListTablesResponse> listTables​(ListTablesRequest request,
                                                     AsyncHandler<ListTablesRequest,​ListTablesResponse> handler)
        Description copied from interface: DataSafeAsync
        Returns a list of table metadata objects.
        Specified by:
        listTables in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListUserAnalyticsResponse> listUserAnalytics​(ListUserAnalyticsRequest request,
                                                                   AsyncHandler<ListUserAnalyticsRequest,​ListUserAnalyticsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listUserAnalytics in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListUserAssessmentsResponse> listUserAssessments​(ListUserAssessmentsRequest request,
                                                                       AsyncHandler<ListUserAssessmentsRequest,​ListUserAssessmentsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listUserAssessments in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ListUsersResponse> listUsers​(ListUsersRequest request,
                                                   AsyncHandler<ListUsersRequest,​ListUsersResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        listUsers in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<MaskDataResponse> maskData​(MaskDataRequest request,
                                                 AsyncHandler<MaskDataRequest,​MaskDataResponse> handler)
        Description copied from interface: DataSafeAsync
        Masks data using the specified masking policy.
        Specified by:
        maskData in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<PatchAlertsResponse> patchAlerts​(PatchAlertsRequest request,
                                                       AsyncHandler<PatchAlertsRequest,​PatchAlertsResponse> handler)
        Description copied from interface: DataSafeAsync
        Updates the status of one or more alert specified by the alert IDs.
        Specified by:
        patchAlerts in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<PatchDiscoveryJobResultsResponse> patchDiscoveryJobResults​(PatchDiscoveryJobResultsRequest request,
                                                                                 AsyncHandler<PatchDiscoveryJobResultsRequest,​PatchDiscoveryJobResultsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        patchDiscoveryJobResults in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<PatchMaskingColumnsResponse> patchMaskingColumns​(PatchMaskingColumnsRequest request,
                                                                       AsyncHandler<PatchMaskingColumnsRequest,​PatchMaskingColumnsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        patchMaskingColumns in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<PatchSensitiveColumnsResponse> patchSensitiveColumns​(PatchSensitiveColumnsRequest request,
                                                                           AsyncHandler<PatchSensitiveColumnsRequest,​PatchSensitiveColumnsResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        patchSensitiveColumns in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<RefreshSecurityAssessmentResponse> refreshSecurityAssessment​(RefreshSecurityAssessmentRequest request,
                                                                                   AsyncHandler<RefreshSecurityAssessmentRequest,​RefreshSecurityAssessmentResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        refreshSecurityAssessment in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<RefreshUserAssessmentResponse> refreshUserAssessment​(RefreshUserAssessmentRequest request,
                                                                           AsyncHandler<RefreshUserAssessmentRequest,​RefreshUserAssessmentResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        refreshUserAssessment in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ResumeAuditTrailResponse> resumeAuditTrail​(ResumeAuditTrailRequest request,
                                                                 AsyncHandler<ResumeAuditTrailRequest,​ResumeAuditTrailResponse> handler)
        Description copied from interface: DataSafeAsync
        Resumes the specified audit trail once it got stopped.
        Specified by:
        resumeAuditTrail in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ResumeWorkRequestResponse> resumeWorkRequest​(ResumeWorkRequestRequest request,
                                                                   AsyncHandler<ResumeWorkRequestRequest,​ResumeWorkRequestResponse> handler)
        Description copied from interface: DataSafeAsync
        Resume the given work request.

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

        Specified by:
        resumeWorkRequest in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<ScheduleReportResponse> scheduleReport​(ScheduleReportRequest request,
                                                             AsyncHandler<ScheduleReportRequest,​ScheduleReportResponse> handler)
        Description copied from interface: DataSafeAsync
        Schedules a .xls or .pdf report based on parameters and report definition.
        Specified by:
        scheduleReport in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<StartAuditTrailResponse> startAuditTrail​(StartAuditTrailRequest request,
                                                               AsyncHandler<StartAuditTrailRequest,​StartAuditTrailResponse> handler)
        Description copied from interface: DataSafeAsync
        Starts collection of audit records on the specified audit trail.
        Specified by:
        startAuditTrail in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<StopAuditTrailResponse> stopAuditTrail​(StopAuditTrailRequest request,
                                                             AsyncHandler<StopAuditTrailRequest,​StopAuditTrailResponse> handler)
        Description copied from interface: DataSafeAsync
        Stops the specified audit trail.
        Specified by:
        stopAuditTrail in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<SuspendWorkRequestResponse> suspendWorkRequest​(SuspendWorkRequestRequest request,
                                                                     AsyncHandler<SuspendWorkRequestRequest,​SuspendWorkRequestResponse> handler)
        Description copied from interface: DataSafeAsync
        Suspend the given work request.

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

        Specified by:
        suspendWorkRequest in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<UnsetSecurityAssessmentBaselineResponse> unsetSecurityAssessmentBaseline​(UnsetSecurityAssessmentBaselineRequest request,
                                                                                               AsyncHandler<UnsetSecurityAssessmentBaselineRequest,​UnsetSecurityAssessmentBaselineResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        unsetSecurityAssessmentBaseline in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<UnsetUserAssessmentBaselineResponse> unsetUserAssessmentBaseline​(UnsetUserAssessmentBaselineRequest request,
                                                                                       AsyncHandler<UnsetUserAssessmentBaselineRequest,​UnsetUserAssessmentBaselineResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        unsetUserAssessmentBaseline in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<UpdateAlertResponse> updateAlert​(UpdateAlertRequest request,
                                                       AsyncHandler<UpdateAlertRequest,​UpdateAlertResponse> handler)
        Description copied from interface: DataSafeAsync
        Updates the status of the specified alert.
        Specified by:
        updateAlert in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<UpdateAuditTrailResponse> updateAuditTrail​(UpdateAuditTrailRequest request,
                                                                 AsyncHandler<UpdateAuditTrailRequest,​UpdateAuditTrailResponse> handler)
        Description copied from interface: DataSafeAsync
        Updates one or more attributes of the specified audit trail.
        Specified by:
        updateAuditTrail in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<UpdateFindingResponse> updateFinding​(UpdateFindingRequest request,
                                                           AsyncHandler<UpdateFindingRequest,​UpdateFindingResponse> handler)
        Description copied from interface: DataSafeAsync
        Updates one or more attributes of the specified finding.
        Specified by:
        updateFinding in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<UpdateMaskingColumnResponse> updateMaskingColumn​(UpdateMaskingColumnRequest request,
                                                                       AsyncHandler<UpdateMaskingColumnRequest,​UpdateMaskingColumnResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        updateMaskingColumn in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<UpdateReportResponse> updateReport​(UpdateReportRequest request,
                                                         AsyncHandler<UpdateReportRequest,​UpdateReportResponse> handler)
        Description copied from interface: DataSafeAsync
        Updates the specified report.

        Only tags can be updated.

        Specified by:
        updateReport in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<UpdateReportDefinitionResponse> updateReportDefinition​(UpdateReportDefinitionRequest request,
                                                                             AsyncHandler<UpdateReportDefinitionRequest,​UpdateReportDefinitionResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        updateReportDefinition in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<UpdateUserAssessmentResponse> updateUserAssessment​(UpdateUserAssessmentRequest request,
                                                                         AsyncHandler<UpdateUserAssessmentRequest,​UpdateUserAssessmentResponse> handler)
        Description copied from interface: DataSafeAsync
        Updates one or more attributes of the specified user assessment.

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

        Specified by:
        updateUserAssessment in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<UploadMaskingPolicyResponse> uploadMaskingPolicy​(UploadMaskingPolicyRequest request,
                                                                       AsyncHandler<UploadMaskingPolicyRequest,​UploadMaskingPolicyResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

        Specified by:
        uploadMaskingPolicy in interface DataSafeAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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

        public Future<UploadSensitiveDataModelResponse> uploadSensitiveDataModel​(UploadSensitiveDataModelRequest request,
                                                                                 AsyncHandler<UploadSensitiveDataModelRequest,​UploadSensitiveDataModelResponse> handler)
        Description copied from interface: DataSafeAsync
        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.

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

        public void useRealmSpecificEndpointTemplate​(boolean useOfRealmSpecificEndpointTemplateEnabled)
        This method should be used to enable or disable the use of realm-specific endpoint template.

        The default value is null. To enable the use of endpoint template defined for the realm in use, set the flag to true To disable the use of endpoint template defined for the realm in use, set the flag to false

        Parameters:
        useOfRealmSpecificEndpointTemplateEnabled - This flag can be set to true or false to enable or disable the use of realm-specific endpoint template respectively
      • populateServiceParametersInEndpoint

        public final void populateServiceParametersInEndpoint​(String endpoint,
                                                              Map<String,​Object> requiredParametersMap)
        Populate the parameters in the endpoint with its corresponding value and update the base endpoint.

        The value will be populated iff the parameter in endpoint is a required request path parameter or a required request query parameter. If not, the parameter in the endpoint will be ignored and left blank.

        Parameters:
        endpoint - The endpoint template in use
        requiredParametersMap - Map of parameter name as key and value set in request path or query parameter as value
      • updateBaseEndpoint

        public final void updateBaseEndpoint​(String endpoint)
        This method should be used for parameterized endpoint templates only.

        This does not include {region} and {secondLevelDomain} parameters.

        Parameters:
        endpoint - The updated endpoint to use
      • setEndpoint

        public final void setEndpoint​(String endpoint)
      • getEndpoint

        public final String getEndpoint()
      • refreshClient

        public final void refreshClient()
        Rebuild the backing HttpClient.

        This will call ClientConfigurators again, and can be used to e.g. refresh the SSL certificate.

      • getClientCommonLibraryVersion

        public String getClientCommonLibraryVersion()
      • getMinimumClientCommonLibraryVersionFromClient

        public Optional<String> getMinimumClientCommonLibraryVersionFromClient()