Package com.oracle.bmc.oda

Interface ManagementAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    ManagementAsyncClient
    @Generated(value="OracleSDKGenerator",
           comments="API Version: 20190506")
public interface ManagementAsync
extends AutoCloseable
    API to create and maintain Oracle Digital Assistant service instances.

    • 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

      • bulkCreateSkillEntities

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

      • changeOdaPrivateEndpointCompartment

        Future<ChangeOdaPrivateEndpointCompartmentResponse> changeOdaPrivateEndpointCompartment​(ChangeOdaPrivateEndpointCompartmentRequest request,
                                                                                        AsyncHandler<ChangeOdaPrivateEndpointCompartmentRequest,​ChangeOdaPrivateEndpointCompartmentResponse> handler)
        Starts an asynchronous job to move the specified ODA Private Endpoint into a different compartment.

        To monitor the status of the job, take the `opc-work-request-id` response header value and use it to call `GET /workRequests/{workRequestID}`. When provided, If-Match is checked against ETag values of the resource.

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

      • createChannel

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

      • createDigitalAssistant

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

      • createOdaPrivateEndpoint

        Future<CreateOdaPrivateEndpointResponse> createOdaPrivateEndpoint​(CreateOdaPrivateEndpointRequest request,
                                                                  AsyncHandler<CreateOdaPrivateEndpointRequest,​CreateOdaPrivateEndpointResponse> handler)
        Starts an asynchronous job to create an ODA Private Endpoint.

        To monitor the status of the job, take the `opc-work-request-id` response header value and use it to call `GET /workRequests/{workRequestID}`.

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

      • createOdaPrivateEndpointAttachment

        Future<CreateOdaPrivateEndpointAttachmentResponse> createOdaPrivateEndpointAttachment​(CreateOdaPrivateEndpointAttachmentRequest request,
                                                                                      AsyncHandler<CreateOdaPrivateEndpointAttachmentRequest,​CreateOdaPrivateEndpointAttachmentResponse> handler)
        Starts an asynchronous job to create an ODA Private Endpoint Attachment.

        To monitor the status of the job, take the `opc-work-request-id` response header value and use it to call `GET /workRequests/{workRequestID}`.

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

      • createOdaPrivateEndpointScanProxy

        Future<CreateOdaPrivateEndpointScanProxyResponse> createOdaPrivateEndpointScanProxy​(CreateOdaPrivateEndpointScanProxyRequest request,
                                                                                    AsyncHandler<CreateOdaPrivateEndpointScanProxyRequest,​CreateOdaPrivateEndpointScanProxyResponse> handler)
        Starts an asynchronous job to create an ODA Private Endpoint Scan Proxy.

        To monitor the status of the job, take the `opc-work-request-id` response header value and use it to call `GET /workRequests/{workRequestID}`.

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

      • createSkill

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

      • createSkillParameter

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

      • createTranslator

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

      • deleteChannel

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

      • deleteDigitalAssistant

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

      • deleteOdaPrivateEndpoint

        Future<DeleteOdaPrivateEndpointResponse> deleteOdaPrivateEndpoint​(DeleteOdaPrivateEndpointRequest request,
                                                                  AsyncHandler<DeleteOdaPrivateEndpointRequest,​DeleteOdaPrivateEndpointResponse> handler)
        Starts an asynchronous job to delete the specified ODA Private Endpoint.

        To monitor the status of the job, take the opc-work-request-id response header value and use it to call GET /workRequests/{workRequestID}.

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

      • deleteOdaPrivateEndpointAttachment

        Future<DeleteOdaPrivateEndpointAttachmentResponse> deleteOdaPrivateEndpointAttachment​(DeleteOdaPrivateEndpointAttachmentRequest request,
                                                                                      AsyncHandler<DeleteOdaPrivateEndpointAttachmentRequest,​DeleteOdaPrivateEndpointAttachmentResponse> handler)
        Starts an asynchronous job to delete the specified ODA Private Endpoint Attachment.

        To monitor the status of the job, take the opc-work-request-id response header value and use it to call GET /workRequests/{workRequestID}.

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

      • deleteOdaPrivateEndpointScanProxy

        Future<DeleteOdaPrivateEndpointScanProxyResponse> deleteOdaPrivateEndpointScanProxy​(DeleteOdaPrivateEndpointScanProxyRequest request,
                                                                                    AsyncHandler<DeleteOdaPrivateEndpointScanProxyRequest,​DeleteOdaPrivateEndpointScanProxyResponse> handler)
        Starts an asynchronous job to delete the specified ODA Private Endpoint Scan Proxy.

        To monitor the status of the job, take the opc-work-request-id response header value and use it to call GET /workRequests/{workRequestID}.

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

      • deleteSkill

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

      • deleteSkillParameter

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

      • deleteTranslator

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

      • exportDigitalAssistant

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

      • exportSkill

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

      • getChannel

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

      • getDigitalAssistant

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

      • getOdaPrivateEndpoint

        Future<GetOdaPrivateEndpointResponse> getOdaPrivateEndpoint​(GetOdaPrivateEndpointRequest request,
                                                            AsyncHandler<GetOdaPrivateEndpointRequest,​GetOdaPrivateEndpointResponse> handler)
        Gets the specified ODA Private 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.

      • getSkill

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

      • getSkillParameter

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

      • getTranslator

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

      • importBot

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

      • listAuthenticationProviders

        Future<ListAuthenticationProvidersResponse> listAuthenticationProviders​(ListAuthenticationProvidersRequest request,
                                                                        AsyncHandler<ListAuthenticationProvidersRequest,​ListAuthenticationProvidersResponse> handler)
        Returns a page of Authentication Providers that belong to the specified Digital Assistant instance.

        If the `opc-next-page` header appears in the response, then there are more items to retrieve. To get the next page in the subsequent GET request, include the header's value as the `page` query parameter.

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

      • listChannels

        Future<ListChannelsResponse> listChannels​(ListChannelsRequest request,
                                          AsyncHandler<ListChannelsRequest,​ListChannelsResponse> handler)
        Returns a page of Channels that belong to the specified Digital Assistant instance.

        If the `opc-next-page` header appears in the response, then there are more items to retrieve. To get the next page in the subsequent GET request, include the header's value as the `page` query parameter.

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

      • listDigitalAssistantParameters

        Future<ListDigitalAssistantParametersResponse> listDigitalAssistantParameters​(ListDigitalAssistantParametersRequest request,
                                                                              AsyncHandler<ListDigitalAssistantParametersRequest,​ListDigitalAssistantParametersResponse> handler)
        Returns a page of Parameters that belong to the specified Digital Assistant.

        If the `opc-next-page` header appears in the response, then there are more items to retrieve. To get the next page in the subsequent GET request, include the header's value as the `page` query parameter.

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

      • listDigitalAssistants

        Future<ListDigitalAssistantsResponse> listDigitalAssistants​(ListDigitalAssistantsRequest request,
                                                            AsyncHandler<ListDigitalAssistantsRequest,​ListDigitalAssistantsResponse> handler)
        Returns a page of Digital Assistants that belong to the specified Digital Assistant instance.

        If the `opc-next-page` header appears in the response, then there are more items to retrieve. To get the next page in the subsequent GET request, include the header's value as the `page` query parameter.

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

      • listOdaPrivateEndpointAttachments

        Future<ListOdaPrivateEndpointAttachmentsResponse> listOdaPrivateEndpointAttachments​(ListOdaPrivateEndpointAttachmentsRequest request,
                                                                                    AsyncHandler<ListOdaPrivateEndpointAttachmentsRequest,​ListOdaPrivateEndpointAttachmentsResponse> handler)
        Returns a page of ODA Instances attached to this ODA Private Endpoint.

        If the `opc-next-page` header appears in the response, then there are more items to retrieve. To get the next page in the subsequent GET request, include the header's value as the `page` query parameter.

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

      • listOdaPrivateEndpointScanProxies

        Future<ListOdaPrivateEndpointScanProxiesResponse> listOdaPrivateEndpointScanProxies​(ListOdaPrivateEndpointScanProxiesRequest request,
                                                                                    AsyncHandler<ListOdaPrivateEndpointScanProxiesRequest,​ListOdaPrivateEndpointScanProxiesResponse> handler)
        Returns a page of ODA Private Endpoint Scan Proxies that belong to the specified ODA Private Endpoint.

        If the `opc-next-page` header appears in the response, then there are more items to retrieve. To get the next page in the subsequent GET request, include the header's value as the `page` query parameter.

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

      • listOdaPrivateEndpoints

        Future<ListOdaPrivateEndpointsResponse> listOdaPrivateEndpoints​(ListOdaPrivateEndpointsRequest request,
                                                                AsyncHandler<ListOdaPrivateEndpointsRequest,​ListOdaPrivateEndpointsResponse> handler)
        Returns a page of ODA Private Endpoints that belong to the specified compartment.

        If the `opc-next-page` header appears in the response, then there are more items to retrieve. To get the next page in the subsequent GET request, include the header's value as the `page` query parameter.

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

      • listSkillParameters

        Future<ListSkillParametersResponse> listSkillParameters​(ListSkillParametersRequest request,
                                                        AsyncHandler<ListSkillParametersRequest,​ListSkillParametersResponse> handler)
        Returns a page of Skill Parameters that belong to the specified Skill.

        If the `opc-next-page` header appears in the response, then there are more items to retrieve. To get the next page in the subsequent GET request, include the header's value as the `page` query parameter.

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

      • listSkills

        Future<ListSkillsResponse> listSkills​(ListSkillsRequest request,
                                      AsyncHandler<ListSkillsRequest,​ListSkillsResponse> handler)
        Returns a page of Skills that belong to the specified Digital Assistant instance.

        If the `opc-next-page` header appears in the response, then there are more items to retrieve. To get the next page in the subsequent GET request, include the header's value as the `page` query parameter.

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

      • listTranslators

        Future<ListTranslatorsResponse> listTranslators​(ListTranslatorsRequest request,
                                                AsyncHandler<ListTranslatorsRequest,​ListTranslatorsResponse> handler)
        Returns a page of Translators that belong to the specified Digital Assistant instance.

        If the `opc-next-page` header appears in the response, then there are more items to retrieve. To get the next page in the subsequent GET request, include the header's value as the `page` query parameter.

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

      • publishDigitalAssistant

        Future<PublishDigitalAssistantResponse> publishDigitalAssistant​(PublishDigitalAssistantRequest request,
                                                                AsyncHandler<PublishDigitalAssistantRequest,​PublishDigitalAssistantResponse> handler)
        Publish a draft Digital Assistant.

        Once published the Digital Assistant cannot be modified.

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

      • publishSkill

        Future<PublishSkillResponse> publishSkill​(PublishSkillRequest request,
                                          AsyncHandler<PublishSkillRequest,​PublishSkillResponse> handler)
        Publish a draft Skill.

        Once published it cannot be modified.

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

      • rotateChannelKeys

        Future<RotateChannelKeysResponse> rotateChannelKeys​(RotateChannelKeysRequest request,
                                                    AsyncHandler<RotateChannelKeysRequest,​RotateChannelKeysResponse> handler)
        This will generate new keys for any generated keys in the Channel (eg.

        secretKey, verifyToken). If a Channel has no generated keys then no changes will be made. Ensure that you take note of the newly generated keys in the response as they will not be returned again.

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

      • startChannel

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

      • stopChannel

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

      • trainSkill

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

      • updateChannel

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

      • updateDigitalAssistant

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

      • updateOdaPrivateEndpoint

        Future<UpdateOdaPrivateEndpointResponse> updateOdaPrivateEndpoint​(UpdateOdaPrivateEndpointRequest request,
                                                                  AsyncHandler<UpdateOdaPrivateEndpointRequest,​UpdateOdaPrivateEndpointResponse> handler)
        Starts an asynchronous job to update the specified ODA Private Endpoint with the information in the request body.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateSkill

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

      • updateSkillParameter

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

      • updateTranslator

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