Interface GenerativeAiAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    GenerativeAiAsyncClient

    @Generated(value="OracleSDKGenerator",
               comments="API Version: 20231130")
    public interface GenerativeAiAsync
    extends AutoCloseable
    OCI Generative AI is a fully managed service that provides a set of state-of-the-art, customizable large language models (LLMs) that cover a wide range of use cases for text generation, summarization, and text embeddings.

    Use the Generative AI service management API to create and manage DedicatedAiCluster, Endpoint, Model, and WorkRequest in the Generative AI service. For example, create a custom model by fine-tuning an out-of-the-box model using your own data, on a fine-tuning dedicated AI cluster. Then, create a hosting dedicated AI cluster with an endpoint to host your custom model.

    To access your custom model endpoints, or to try the out-of-the-box models to generate text, summarize, and create text embeddings see the [Generative AI Inference API](https://docs.oracle.com/iaas/api/#/en/generative-ai-inference/latest/).

    To learn more about the service, see the [Generative AI documentation](https://docs.oracle.com/iaas/Content/generative-ai/home.htm).

    • 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
      • addArtifact

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

        Future<CreateApiKeyResponse> createApiKey​(CreateApiKeyRequest request,
                                                  AsyncHandler<CreateApiKeyRequest,​CreateApiKeyResponse> handler)
        Creates a new API key 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.
      • createEndpoint

        Future<CreateEndpointResponse> createEndpoint​(CreateEndpointRequest request,
                                                      AsyncHandler<CreateEndpointRequest,​CreateEndpointResponse> handler)
        Creates an endpoint.

        The header contains an opc-work-request-id, which is the id for the WorkRequest that tracks the endpoint creation progress.

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

        Future<CreateGenerativeAiProjectResponse> createGenerativeAiProject​(CreateGenerativeAiProjectRequest request,
                                                                            AsyncHandler<CreateGenerativeAiProjectRequest,​CreateGenerativeAiProjectResponse> handler)
        Creates a GenerativeAiProject.

        The header contains an opc-work-request-id, which is the id for the WorkRequest that tracks the generativeAiProject creation progress.

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

        Future<CreateImportedModelResponse> createImportedModel​(CreateImportedModelRequest request,
                                                                AsyncHandler<CreateImportedModelRequest,​CreateImportedModelResponse> handler)
        Import a model from ModelDataSource.

        The header contains an opc-work-request-id, which is the id for the WorkRequest that tracks the importedModel creation progress.

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

        Future<CreateModelResponse> createModel​(CreateModelRequest request,
                                                AsyncHandler<CreateModelRequest,​CreateModelResponse> handler)
        Creates a custom model by fine-tuning a base model with your own dataset.

        You can create a new custom models or create a new version of existing custom model..

        The header contains an opc-work-request-id, which is the id for the WorkRequest that tracks the model creation progress.

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

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

        Future<CreateVectorStoreConnectorResponse> createVectorStoreConnector​(CreateVectorStoreConnectorRequest request,
                                                                              AsyncHandler<CreateVectorStoreConnectorRequest,​CreateVectorStoreConnectorResponse> handler)
        Creates a VectorStoreConnector.

        The header contains an opc-work-request-id, which is the id for the WorkRequest that tracks the vectorStoreConnector creation progress.

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

        Future<CreateVectorStoreConnectorFileSyncResponse> createVectorStoreConnectorFileSync​(CreateVectorStoreConnectorFileSyncRequest request,
                                                                                              AsyncHandler<CreateVectorStoreConnectorFileSyncRequest,​CreateVectorStoreConnectorFileSyncResponse> handler)
        Creates a File Sync operation for a VectorStoreConnector.

        The header contains an opc-work-request-id, which is the id for the WorkRequest that tracks the vectorStoreConnectorFileSync creation progress.

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

        Future<DeleteApiKeyResponse> deleteApiKey​(DeleteApiKeyRequest request,
                                                  AsyncHandler<DeleteApiKeyRequest,​DeleteApiKeyResponse> handler)
        Deletes an API 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.
      • deleteDedicatedAiCluster

        Future<DeleteDedicatedAiClusterResponse> deleteDedicatedAiCluster​(DeleteDedicatedAiClusterRequest request,
                                                                          AsyncHandler<DeleteDedicatedAiClusterRequest,​DeleteDedicatedAiClusterResponse> handler)
        Deletes a dedicated AI cluster.

        You can only delete clusters without attached resources. Before you delete a hosting dedicated AI cluster, you must delete the endpoints associated to that cluster. Before you delete a fine-tuning dedicated AI cluster, you must delete the custom model on that cluster. The delete action permanently deletes the cluster. This action can't be undone.

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

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

        Future<DeleteHostedApplicationResponse> deleteHostedApplication​(DeleteHostedApplicationRequest request,
                                                                        AsyncHandler<DeleteHostedApplicationRequest,​DeleteHostedApplicationResponse> handler)
        Deletes a hosted application.

        You can only delete hosted application without attached resources. Before you delete a hosting hosted application, you must delete the endpoints associated to that application. Before you delete a fine-tuning hosted application, you must delete the custom model on that application. The delete action permanently deletes the cluster. This action can’t be undone.

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

        Future<DeleteHostedApplicationStorageResponse> deleteHostedApplicationStorage​(DeleteHostedApplicationStorageRequest request,
                                                                                      AsyncHandler<DeleteHostedApplicationStorageRequest,​DeleteHostedApplicationStorageResponse> handler)
        Deletes a hosted application.

        You can only delete hosted application without attached resources. Before you delete a hosting hosted application, you must delete the endpoints associated to that application. Before you delete a fine-tuning hosted application, you must delete the custom model on that application. The delete action permanently deletes the cluster. This action can’t be undone.

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

        Future<DeleteHostedDeploymentResponse> deleteHostedDeployment​(DeleteHostedDeploymentRequest request,
                                                                      AsyncHandler<DeleteHostedDeploymentRequest,​DeleteHostedDeploymentResponse> handler)
        Deletes a hosted deployment.

        You can only delete hosted deployment without attached resources. Before you delete a hosting hosted deployment, you must delete the endpoints associated to that deployment. Before you delete a fine-tuning hosted deployment, you must delete the custom model on that deployment. The delete action permanently deletes the cluster. This action can’t be undone.

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

        Future<DeleteImportedModelResponse> deleteImportedModel​(DeleteImportedModelRequest request,
                                                                AsyncHandler<DeleteImportedModelRequest,​DeleteImportedModelResponse> handler)
        Deletes an imported model.

        An imported model shouldn’t be deleted if there’s one or more active endpoints associated with that imported 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.
      • deleteModel

        Future<DeleteModelResponse> deleteModel​(DeleteModelRequest request,
                                                AsyncHandler<DeleteModelRequest,​DeleteModelResponse> handler)
        Deletes a custom model.

        A model shouldn’t be deleted if there’s one or more active endpoints associated with that 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.
      • deleteSemanticStore

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

        Future<GetApiKeyResponse> getApiKey​(GetApiKeyRequest request,
                                            AsyncHandler<GetApiKeyRequest,​GetApiKeyResponse> handler)
        Gets information about an API 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.
      • getDedicatedAiCluster

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

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

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

        Future<GetHostedApplicationResponse> getHostedApplication​(GetHostedApplicationRequest request,
                                                                  AsyncHandler<GetHostedApplicationRequest,​GetHostedApplicationResponse> handler)
        Gets information about a hosted 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.
      • getHostedDeployment

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

        Future<GetImportedModelResponse> getImportedModel​(GetImportedModelRequest request,
                                                          AsyncHandler<GetImportedModelRequest,​GetImportedModelResponse> handler)
        Gets information about an imported 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.
      • getModel

        Future<GetModelResponse> getModel​(GetModelRequest request,
                                          AsyncHandler<GetModelRequest,​GetModelResponse> handler)
        Gets information about a custom 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.
      • getSemanticStore

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

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

        Future<GetWorkRequestResponse> getWorkRequest​(GetWorkRequestRequest request,
                                                      AsyncHandler<GetWorkRequestRequest,​GetWorkRequestResponse> handler)
        Gets the details of a 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.
      • listApiKeys

        Future<ListApiKeysResponse> listApiKeys​(ListApiKeysRequest request,
                                                AsyncHandler<ListApiKeysRequest,​ListApiKeysResponse> handler)
        Lists the ApiKeys of a specific 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.
      • listDedicatedAiClusters

        Future<ListDedicatedAiClustersResponse> listDedicatedAiClusters​(ListDedicatedAiClustersRequest request,
                                                                        AsyncHandler<ListDedicatedAiClustersRequest,​ListDedicatedAiClustersResponse> handler)
        Lists the dedicated AI clusters in a specific 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.
      • listEndpoints

        Future<ListEndpointsResponse> listEndpoints​(ListEndpointsRequest request,
                                                    AsyncHandler<ListEndpointsRequest,​ListEndpointsResponse> handler)
        Lists the endpoints of a specific 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.
      • listGenerativeAiProjects

        Future<ListGenerativeAiProjectsResponse> listGenerativeAiProjects​(ListGenerativeAiProjectsRequest request,
                                                                          AsyncHandler<ListGenerativeAiProjectsRequest,​ListGenerativeAiProjectsResponse> handler)
        Lists the generativeAiProjects of a specific 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.
      • listHostedApplications

        Future<ListHostedApplicationsResponse> listHostedApplications​(ListHostedApplicationsRequest request,
                                                                      AsyncHandler<ListHostedApplicationsRequest,​ListHostedApplicationsResponse> handler)
        Lists the hosted applications in a specific 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.
      • listHostedDeployments

        Future<ListHostedDeploymentsResponse> listHostedDeployments​(ListHostedDeploymentsRequest request,
                                                                    AsyncHandler<ListHostedDeploymentsRequest,​ListHostedDeploymentsResponse> handler)
        Lists the hosted applications in a specific 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.
      • listImportedModels

        Future<ListImportedModelsResponse> listImportedModels​(ListImportedModelsRequest request,
                                                              AsyncHandler<ListImportedModelsRequest,​ListImportedModelsResponse> handler)
        Lists imported models in a specific 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.
      • listModels

        Future<ListModelsResponse> listModels​(ListModelsRequest request,
                                              AsyncHandler<ListModelsRequest,​ListModelsResponse> handler)
        Lists the models in a specific compartment.

        Includes pretrained base models and fine-tuned custom models.

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

        Future<ListSemanticStoresResponse> listSemanticStores​(ListSemanticStoresRequest request,
                                                              AsyncHandler<ListSemanticStoresRequest,​ListSemanticStoresResponse> handler)
        Lists the SemanticStores given specific filter.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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)
        Lists the errors for a 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)
        Lists the logs for a 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.
      • renewApiKey

        Future<RenewApiKeyResponse> renewApiKey​(RenewApiKeyRequest request,
                                                AsyncHandler<RenewApiKeyRequest,​RenewApiKeyResponse> handler)
        Renew the primary or secondary 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.
      • setApiKeyState

        Future<SetApiKeyStateResponse> setApiKeyState​(SetApiKeyStateRequest request,
                                                      AsyncHandler<SetApiKeyStateRequest,​SetApiKeyStateResponse> handler)
        Set state of the 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.
      • updateApiKey

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

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

        Future<UpdateImportedModelResponse> updateImportedModel​(UpdateImportedModelRequest request,
                                                                AsyncHandler<UpdateImportedModelRequest,​UpdateImportedModelResponse> handler)
        Updates the properties of an imported model such as name, description, freeform tags, and defined tags.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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 properties of a custom model such as name, description, version, freeform tags, and defined tags.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateSemanticStore

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