Package com.oracle.bmc.aivision

Interface AIServiceVisionAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    AIServiceVisionAsyncClient
    @Generated(value="OracleSDKGenerator",
           comments="API Version: 20220125")
public interface AIServiceVisionAsync
extends AutoCloseable
    Using Vision, you can upload images to detect and classify objects in them.

    If you have lots of images, you can process them in batch using asynchronous API endpoints. Vision’s features are thematically split between Document AI for document-centric images, and Image Analysis for object and scene-based images. Pretrained models and custom models are supported.

    • 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

      • analyzeDocument

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

      • analyzeImage

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

      • cancelDocumentJob

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

      • cancelImageJob

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

      • cancelVideoJob

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

      • cancelWorkRequest

        Future<CancelWorkRequestResponse> cancelWorkRequest​(CancelWorkRequestRequest request,
                                                    AsyncHandler<CancelWorkRequestRequest,​CancelWorkRequestResponse> handler)
        Cancel 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.

      • changeModelCompartment

        Future<ChangeModelCompartmentResponse> changeModelCompartment​(ChangeModelCompartmentRequest request,
                                                              AsyncHandler<ChangeModelCompartmentRequest,​ChangeModelCompartmentResponse> handler)
        Moves a model from one compartment to another.

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

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

      • changeProjectCompartment

        Future<ChangeProjectCompartmentResponse> changeProjectCompartment​(ChangeProjectCompartmentRequest request,
                                                                  AsyncHandler<ChangeProjectCompartmentRequest,​ChangeProjectCompartmentResponse> handler)
        Move a project from one compartment to another.

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

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

      • changeStreamGroupCompartment

        Future<ChangeStreamGroupCompartmentResponse> changeStreamGroupCompartment​(ChangeStreamGroupCompartmentRequest request,
                                                                          AsyncHandler<ChangeStreamGroupCompartmentRequest,​ChangeStreamGroupCompartmentResponse> handler)
        Move a streamGroup from one compartment to another.

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

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

      • changeStreamJobCompartment

        Future<ChangeStreamJobCompartmentResponse> changeStreamJobCompartment​(ChangeStreamJobCompartmentRequest request,
                                                                      AsyncHandler<ChangeStreamJobCompartmentRequest,​ChangeStreamJobCompartmentResponse> handler)
        Move a streamJob from one compartment to another.

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

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

      • changeStreamSourceCompartment

        Future<ChangeStreamSourceCompartmentResponse> changeStreamSourceCompartment​(ChangeStreamSourceCompartmentRequest request,
                                                                            AsyncHandler<ChangeStreamSourceCompartmentRequest,​ChangeStreamSourceCompartmentResponse> handler)
        Move a streamSource from one compartment to another.

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

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

      • createDocumentJob

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

      • createImageJob

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

      • createModel

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

      • createProject

        Future<CreateProjectResponse> createProject​(CreateProjectRequest request,
                                            AsyncHandler<CreateProjectRequest,​CreateProjectResponse> handler)
        Create a new 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.

      • createStreamGroup

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

      • createStreamJob

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

      • createStreamSource

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

      • createVideoJob

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

      • deleteModel

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

      • deleteProject

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

      • deleteStreamGroup

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

      • deleteStreamJob

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

      • deleteStreamSource

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

      • getDocumentJob

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

      • getImageJob

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

      • getModel

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

      • getProject

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

      • getStreamGroup

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

      • getStreamJob

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

      • getStreamSource

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

      • getVideoJob

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

      • getWorkRequest

        Future<GetWorkRequestResponse> getWorkRequest​(GetWorkRequestRequest request,
                                              AsyncHandler<GetWorkRequestRequest,​GetWorkRequestResponse> handler)
        Gets 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.

      • listModels

        Future<ListModelsResponse> listModels​(ListModelsRequest request,
                                      AsyncHandler<ListModelsRequest,​ListModelsResponse> handler)
        Returns a list of models 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.

      • listProjects

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

      • listStreamGroups

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

      • listStreamJobs

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

      • listStreamSources

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

      • listWorkRequestErrors

        Future<ListWorkRequestErrorsResponse> listWorkRequestErrors​(ListWorkRequestErrorsRequest request,
                                                            AsyncHandler<ListWorkRequestErrorsRequest,​ListWorkRequestErrorsResponse> handler)
        Returns 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)
        Return 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.

      • startStreamJob

        Future<StartStreamJobResponse> startStreamJob​(StartStreamJobRequest request,
                                              AsyncHandler<StartStreamJobRequest,​StartStreamJobResponse> handler)
        End a stream analysis 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.

      • stopStreamJob

        Future<StopStreamJobResponse> stopStreamJob​(StopStreamJobRequest request,
                                            AsyncHandler<StopStreamJobRequest,​StopStreamJobResponse> handler)
        End a stream analysis 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.

      • updateModel

        Future<UpdateModelResponse> updateModel​(UpdateModelRequest request,
                                        AsyncHandler<UpdateModelRequest,​UpdateModelResponse> handler)
        Updates the model metadata.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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)
        Update the project metadata.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateStreamGroup

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

      • updateStreamJob

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

      • updateStreamSource

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