Interface DataIntegrationAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    DataIntegrationAsyncClient

    @Generated(value="OracleSDKGenerator",
               comments="API Version: 20200430")
    public interface DataIntegrationAsync
    extends AutoCloseable
    Use the Data Integration API to organize your data integration projects, create data flows, pipelines and tasks, and then publish, schedule, and run tasks that extract, transform, and load data.

    For more information, see Data Integration.

    • Method Detail

      • refreshClient

        void refreshClient()
        Rebuilds the client from scratch.

        Useful to refresh certificates.

      • setEndpoint

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

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

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

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

        Parameters:
        region - The region of the service.
      • setRegion

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

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

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

        Parameters:
        regionId - The public region ID.
      • useRealmSpecificEndpointTemplate

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

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

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

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

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

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

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

        Future<CreateDataFlowResponse> createDataFlow​(CreateDataFlowRequest request,
                                                      AsyncHandler<CreateDataFlowRequest,​CreateDataFlowResponse> handler)
        Creates a new data flow in a project or folder ready for performing data integrations.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createDataFlowValidation

        Future<CreateDataFlowValidationResponse> createDataFlowValidation​(CreateDataFlowValidationRequest request,
                                                                          AsyncHandler<CreateDataFlowValidationRequest,​CreateDataFlowValidationResponse> handler)
        Accepts the data flow definition in the request payload and creates a data flow validation.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createDisApplication

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

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

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

        Future<CreateFolderResponse> createFolder​(CreateFolderRequest request,
                                                  AsyncHandler<CreateFolderRequest,​CreateFolderResponse> handler)
        Creates a folder in a project or in another folder, limited to two levels of folders.

        | Folders are used to organize your design-time resources, such as tasks or data flows.

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

        Future<CreateFunctionLibraryResponse> createFunctionLibrary​(CreateFunctionLibraryRequest request,
                                                                    AsyncHandler<CreateFunctionLibraryRequest,​CreateFunctionLibraryResponse> handler)
        Creates a function library in a project or in another function library, limited to two levels of function libraries.

        | FunctionLibraries are used to organize your design-time resources, such as tasks or data flows.

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

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

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

        Future<CreatePipelineResponse> createPipeline​(CreatePipelineRequest request,
                                                      AsyncHandler<CreatePipelineRequest,​CreatePipelineResponse> handler)
        Creates a new pipeline in a project or folder ready for performing task orchestration.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createPipelineValidation

        Future<CreatePipelineValidationResponse> createPipelineValidation​(CreatePipelineValidationRequest request,
                                                                          AsyncHandler<CreatePipelineValidationRequest,​CreatePipelineValidationResponse> handler)
        Accepts the data flow definition in the request payload and creates a pipeline validation.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createProject

        Future<CreateProjectResponse> createProject​(CreateProjectRequest request,
                                                    AsyncHandler<CreateProjectRequest,​CreateProjectResponse> handler)
        Creates a project.

        Projects are organizational constructs within a workspace that you use to organize your design-time resources, such as tasks or data flows. Projects can be organized into folders.

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

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

        Future<CreateTaskResponse> createTask​(CreateTaskRequest request,
                                              AsyncHandler<CreateTaskRequest,​CreateTaskResponse> handler)
        Creates a new task ready for performing data integrations.

        There are specialized types of tasks that include data loader and integration tasks.

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

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

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

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

        Future<CreateUserDefinedFunctionResponse> createUserDefinedFunction​(CreateUserDefinedFunctionRequest request,
                                                                            AsyncHandler<CreateUserDefinedFunctionRequest,​CreateUserDefinedFunctionResponse> handler)
        Creates a new UserDefinedFunction in a function library ready for performing data integrations.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createWorkspace

        Future<CreateWorkspaceResponse> createWorkspace​(CreateWorkspaceRequest request,
                                                        AsyncHandler<CreateWorkspaceRequest,​CreateWorkspaceResponse> handler)
        Creates a new Data Integration workspace ready for performing data integration tasks.

        To retrieve the OCID for the new workspace, use the opc-work-request-id returned by this API and call the getWorkRequest API.

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

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

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

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

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

        Future<DeleteDataFlowResponse> deleteDataFlow​(DeleteDataFlowRequest request,
                                                      AsyncHandler<DeleteDataFlowRequest,​DeleteDataFlowResponse> handler)
        Removes a data flow from a project or folder using the specified identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteDataFlowValidation

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

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

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

        Future<DeleteFolderResponse> deleteFolder​(DeleteFolderRequest request,
                                                  AsyncHandler<DeleteFolderRequest,​DeleteFolderResponse> handler)
        Removes a folder from a project using the specified identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteFunctionLibrary

        Future<DeleteFunctionLibraryResponse> deleteFunctionLibrary​(DeleteFunctionLibraryRequest request,
                                                                    AsyncHandler<DeleteFunctionLibraryRequest,​DeleteFunctionLibraryResponse> handler)
        Removes a Function Library from a project using the specified identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteImportRequest

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

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

        Future<DeletePipelineResponse> deletePipeline​(DeletePipelineRequest request,
                                                      AsyncHandler<DeletePipelineRequest,​DeletePipelineResponse> handler)
        Removes a pipeline from a project or folder using the specified identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deletePipelineValidation

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

        Future<DeleteProjectResponse> deleteProject​(DeleteProjectRequest request,
                                                    AsyncHandler<DeleteProjectRequest,​DeleteProjectResponse> handler)
        Removes a project from the workspace using the specified identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteSchedule

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

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

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

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

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

        Future<DeleteUserDefinedFunctionResponse> deleteUserDefinedFunction​(DeleteUserDefinedFunctionRequest request,
                                                                            AsyncHandler<DeleteUserDefinedFunctionRequest,​DeleteUserDefinedFunctionResponse> handler)
        Removes a UserDefinedFunction from a function library using the specified identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteWorkspace

        Future<DeleteWorkspaceResponse> deleteWorkspace​(DeleteWorkspaceRequest request,
                                                        AsyncHandler<DeleteWorkspaceRequest,​DeleteWorkspaceResponse> handler)
        Deletes a Data Integration workspace resource using the specified identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getApplication

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

        Future<GetCompositeStateResponse> getCompositeState​(GetCompositeStateRequest request,
                                                            AsyncHandler<GetCompositeStateRequest,​GetCompositeStateResponse> handler)
        This endpoint can be used to get composite state for a given aggregator
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getConnection

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

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

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

        Future<GetCountStatisticResponse> getCountStatistic​(GetCountStatisticRequest request,
                                                            AsyncHandler<GetCountStatisticRequest,​GetCountStatisticResponse> handler)
        Retrieves statistics on a workspace.

        It returns an object with an array of property values, such as the number of projects, | applications, data assets, and so on.

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

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

        Future<GetDataEntityResponse> getDataEntity​(GetDataEntityRequest request,
                                                    AsyncHandler<GetDataEntityRequest,​GetDataEntityResponse> handler)
        Retrieves the data entity details with the given name from live schema.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getDataFlow

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        Future<GetWorkspaceResponse> getWorkspace​(GetWorkspaceRequest request,
                                                  AsyncHandler<GetWorkspaceRequest,​GetWorkspaceResponse> handler)
        Retrieves a Data Integration workspace using the specified identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listApplications

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

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

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

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

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

        Future<ListDataEntitiesResponse> listDataEntities​(ListDataEntitiesRequest request,
                                                          AsyncHandler<ListDataEntitiesRequest,​ListDataEntitiesResponse> handler)
        Lists a summary of data entities from the data asset using the specified connection.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listDataFlowValidations

        Future<ListDataFlowValidationsResponse> listDataFlowValidations​(ListDataFlowValidationsRequest request,
                                                                        AsyncHandler<ListDataFlowValidationsRequest,​ListDataFlowValidationsResponse> handler)
        Retrieves a list of data flow validations within the specified workspace.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listDataFlows

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

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

        Future<ListDisApplicationsResponse> listDisApplications​(ListDisApplicationsRequest request,
                                                                AsyncHandler<ListDisApplicationsRequest,​ListDisApplicationsResponse> handler)
        Retrieves a list of DIS Applications in a compartment and provides options to filter the list.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listExportRequests

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

        Future<ListExternalPublicationsResponse> listExternalPublications​(ListExternalPublicationsRequest request,
                                                                          AsyncHandler<ListExternalPublicationsRequest,​ListExternalPublicationsResponse> handler)
        Retrieves a list of external publications in an application and provides options to filter the list.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listFolders

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

        Future<ListFunctionLibrariesResponse> listFunctionLibraries​(ListFunctionLibrariesRequest request,
                                                                    AsyncHandler<ListFunctionLibrariesRequest,​ListFunctionLibrariesResponse> handler)
        Retrieves a list of function libraries in a project and provides options to filter the list.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listImportRequests

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

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

        Future<ListPatchesResponse> listPatches​(ListPatchesRequest request,
                                                AsyncHandler<ListPatchesRequest,​ListPatchesResponse> handler)
        Retrieves a list of patches in an application and provides options to filter the list.

        For listing changes based on a period and logical objects changed, see ListPatchChanges API.

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

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

        Future<ListPipelinesResponse> listPipelines​(ListPipelinesRequest request,
                                                    AsyncHandler<ListPipelinesRequest,​ListPipelinesResponse> handler)
        Retrieves a list of pipelines in a project or folder from within a workspace, the query parameter specifies the project or folder.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listProjects

        Future<ListProjectsResponse> listProjects​(ListProjectsRequest request,
                                                  AsyncHandler<ListProjectsRequest,​ListProjectsResponse> handler)
        Retrieves a lists of projects in a workspace and provides options to filter the list.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listPublishedObjects

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

        Future<ListReferencesResponse> listReferences​(ListReferencesRequest request,
                                                      AsyncHandler<ListReferencesRequest,​ListReferencesResponse> handler)
        Retrieves a list of references in an application.

        Reference objects are created when dataflows and tasks use objects, such as data assets and connections.

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

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

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

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

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

        Future<ListTaskRunLineagesResponse> listTaskRunLineages​(ListTaskRunLineagesRequest request,
                                                                AsyncHandler<ListTaskRunLineagesRequest,​ListTaskRunLineagesResponse> handler)
        This endpoint can be used to list Task Run Lineages within a given time window.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listTaskRunLogs

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        Future<UpdateDataAssetResponse> updateDataAsset​(UpdateDataAssetRequest request,
                                                        AsyncHandler<UpdateDataAssetRequest,​UpdateDataAssetResponse> handler)
        Updates a specific data asset with default connection.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateDataFlow

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

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

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

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

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

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

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

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

        Future<UpdateReferenceResponse> updateReference​(UpdateReferenceRequest request,
                                                        AsyncHandler<UpdateReferenceRequest,​UpdateReferenceResponse> handler)
        Updates the application references.

        For example, to map a data asset to a different target object.

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

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

        Future<UpdateTaskResponse> updateTask​(UpdateTaskRequest request,
                                              AsyncHandler<UpdateTaskRequest,​UpdateTaskResponse> handler)
        Updates a specific task.

        For example, you can update the task description or move the task to a different folder by changing the aggregatorKey to a different folder in the registry.

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

        Future<UpdateTaskRunResponse> updateTaskRun​(UpdateTaskRunRequest request,
                                                    AsyncHandler<UpdateTaskRunRequest,​UpdateTaskRunResponse> handler)
        Updates the status of the task run.

        For example, aborts a task run.

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

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

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