software.amazon.awssdk.services.lexmodelbuilding.DefaultLexModelBuildingAsyncClient Maven / Gradle / Ivy
/*
* Copyright 2014-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package software.amazon.awssdk.services.lexmodelbuilding;
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import software.amazon.awssdk.annotations.Generated;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.awscore.AwsRequestOverrideConfiguration;
import software.amazon.awssdk.awscore.client.handler.AwsAsyncClientHandler;
import software.amazon.awssdk.awscore.exception.AwsServiceException;
import software.amazon.awssdk.core.ApiName;
import software.amazon.awssdk.core.client.config.SdkClientConfiguration;
import software.amazon.awssdk.core.client.handler.AsyncClientHandler;
import software.amazon.awssdk.core.client.handler.ClientExecutionParams;
import software.amazon.awssdk.core.http.HttpResponseHandler;
import software.amazon.awssdk.core.util.VersionInfo;
import software.amazon.awssdk.protocols.core.ExceptionMetadata;
import software.amazon.awssdk.protocols.json.AwsJsonProtocol;
import software.amazon.awssdk.protocols.json.AwsJsonProtocolFactory;
import software.amazon.awssdk.protocols.json.BaseAwsJsonProtocolFactory;
import software.amazon.awssdk.protocols.json.JsonOperationMetadata;
import software.amazon.awssdk.services.lexmodelbuilding.model.BadRequestException;
import software.amazon.awssdk.services.lexmodelbuilding.model.ConflictException;
import software.amazon.awssdk.services.lexmodelbuilding.model.CreateBotVersionRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.CreateBotVersionResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.CreateIntentVersionRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.CreateIntentVersionResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.CreateSlotTypeVersionRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.CreateSlotTypeVersionResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.DeleteBotAliasRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.DeleteBotAliasResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.DeleteBotChannelAssociationRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.DeleteBotChannelAssociationResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.DeleteBotRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.DeleteBotResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.DeleteBotVersionRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.DeleteBotVersionResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.DeleteIntentRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.DeleteIntentResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.DeleteIntentVersionRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.DeleteIntentVersionResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.DeleteSlotTypeRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.DeleteSlotTypeResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.DeleteSlotTypeVersionRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.DeleteSlotTypeVersionResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.DeleteUtterancesRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.DeleteUtterancesResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBotAliasRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBotAliasResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBotAliasesRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBotAliasesResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBotChannelAssociationRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBotChannelAssociationResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBotChannelAssociationsRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBotChannelAssociationsResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBotRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBotResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBotVersionsRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBotVersionsResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBotsRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBotsResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBuiltinIntentRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBuiltinIntentResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBuiltinIntentsRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBuiltinIntentsResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBuiltinSlotTypesRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBuiltinSlotTypesResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetExportRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetExportResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetImportRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetImportResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetIntentRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetIntentResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetIntentVersionsRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetIntentVersionsResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetIntentsRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetIntentsResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetSlotTypeRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetSlotTypeResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetSlotTypeVersionsRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetSlotTypeVersionsResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetSlotTypesRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetSlotTypesResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetUtterancesViewRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetUtterancesViewResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.InternalFailureException;
import software.amazon.awssdk.services.lexmodelbuilding.model.LexModelBuildingException;
import software.amazon.awssdk.services.lexmodelbuilding.model.LexModelBuildingRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.LimitExceededException;
import software.amazon.awssdk.services.lexmodelbuilding.model.NotFoundException;
import software.amazon.awssdk.services.lexmodelbuilding.model.PreconditionFailedException;
import software.amazon.awssdk.services.lexmodelbuilding.model.PutBotAliasRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.PutBotAliasResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.PutBotRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.PutBotResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.PutIntentRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.PutIntentResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.PutSlotTypeRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.PutSlotTypeResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.ResourceInUseException;
import software.amazon.awssdk.services.lexmodelbuilding.model.StartImportRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.StartImportResponse;
import software.amazon.awssdk.services.lexmodelbuilding.paginators.GetBotAliasesPublisher;
import software.amazon.awssdk.services.lexmodelbuilding.paginators.GetBotChannelAssociationsPublisher;
import software.amazon.awssdk.services.lexmodelbuilding.paginators.GetBotVersionsPublisher;
import software.amazon.awssdk.services.lexmodelbuilding.paginators.GetBotsPublisher;
import software.amazon.awssdk.services.lexmodelbuilding.paginators.GetBuiltinIntentsPublisher;
import software.amazon.awssdk.services.lexmodelbuilding.paginators.GetBuiltinSlotTypesPublisher;
import software.amazon.awssdk.services.lexmodelbuilding.paginators.GetIntentVersionsPublisher;
import software.amazon.awssdk.services.lexmodelbuilding.paginators.GetIntentsPublisher;
import software.amazon.awssdk.services.lexmodelbuilding.paginators.GetSlotTypeVersionsPublisher;
import software.amazon.awssdk.services.lexmodelbuilding.paginators.GetSlotTypesPublisher;
import software.amazon.awssdk.services.lexmodelbuilding.transform.CreateBotVersionRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.CreateIntentVersionRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.CreateSlotTypeVersionRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.DeleteBotAliasRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.DeleteBotChannelAssociationRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.DeleteBotRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.DeleteBotVersionRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.DeleteIntentRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.DeleteIntentVersionRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.DeleteSlotTypeRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.DeleteSlotTypeVersionRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.DeleteUtterancesRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.GetBotAliasRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.GetBotAliasesRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.GetBotChannelAssociationRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.GetBotChannelAssociationsRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.GetBotRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.GetBotVersionsRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.GetBotsRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.GetBuiltinIntentRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.GetBuiltinIntentsRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.GetBuiltinSlotTypesRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.GetExportRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.GetImportRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.GetIntentRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.GetIntentVersionsRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.GetIntentsRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.GetSlotTypeRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.GetSlotTypeVersionsRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.GetSlotTypesRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.GetUtterancesViewRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.PutBotAliasRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.PutBotRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.PutIntentRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.PutSlotTypeRequestMarshaller;
import software.amazon.awssdk.services.lexmodelbuilding.transform.StartImportRequestMarshaller;
import software.amazon.awssdk.utils.CompletableFutureUtils;
/**
* Internal implementation of {@link LexModelBuildingAsyncClient}.
*
* @see LexModelBuildingAsyncClient#builder()
*/
@Generated("software.amazon.awssdk:codegen")
@SdkInternalApi
final class DefaultLexModelBuildingAsyncClient implements LexModelBuildingAsyncClient {
private static final Logger log = LoggerFactory.getLogger(DefaultLexModelBuildingAsyncClient.class);
private final AsyncClientHandler clientHandler;
private final AwsJsonProtocolFactory protocolFactory;
private final SdkClientConfiguration clientConfiguration;
protected DefaultLexModelBuildingAsyncClient(SdkClientConfiguration clientConfiguration) {
this.clientHandler = new AwsAsyncClientHandler(clientConfiguration);
this.clientConfiguration = clientConfiguration;
this.protocolFactory = init(AwsJsonProtocolFactory.builder()).build();
}
@Override
public final String serviceName() {
return SERVICE_NAME;
}
/**
*
* Creates a new version of the bot based on the $LATEST version. If the $LATEST
* version of this resource hasn't changed since you created the last version, Amazon Lex doesn't create a new
* version. It returns the last created version.
*
*
*
* You can update only the $LATEST version of the bot. You can't update the numbered versions that
* you create with the CreateBotVersion operation.
*
*
*
* When you create the first version of a bot, Amazon Lex sets the version to 1. Subsequent versions increment by 1.
* For more information, see versioning-intro.
*
*
* This operation requires permission for the lex:CreateBotVersion action.
*
*
* @param createBotVersionRequest
* @return A Java Future containing the result of the CreateBotVersion operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - ConflictException There was a conflict processing the request. Try your request again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - PreconditionFailedException The checksum of the resource that you are trying to change does not match
* the checksum in the request. Check the resource's checksum and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.CreateBotVersion
* @see AWS
* API Documentation
*/
@Override
public CompletableFuture createBotVersion(CreateBotVersionRequest createBotVersionRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, CreateBotVersionResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("CreateBotVersion")
.withMarshaller(new CreateBotVersionRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(createBotVersionRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Creates a new version of an intent based on the $LATEST version of the intent. If the
* $LATEST version of this intent hasn't changed since you last updated it, Amazon Lex doesn't
* create a new version. It returns the last version you created.
*
*
*
* You can update only the $LATEST version of the intent. You can't update the numbered versions
* that you create with the CreateIntentVersion operation.
*
*
*
* When you create a version of an intent, Amazon Lex sets the version to 1. Subsequent versions increment by 1. For
* more information, see versioning-intro.
*
*
* This operation requires permissions to perform the lex:CreateIntentVersion action.
*
*
* @param createIntentVersionRequest
* @return A Java Future containing the result of the CreateIntentVersion operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - ConflictException There was a conflict processing the request. Try your request again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - PreconditionFailedException The checksum of the resource that you are trying to change does not match
* the checksum in the request. Check the resource's checksum and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.CreateIntentVersion
* @see AWS
* API Documentation
*/
@Override
public CompletableFuture createIntentVersion(
CreateIntentVersionRequest createIntentVersionRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, CreateIntentVersionResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("CreateIntentVersion")
.withMarshaller(new CreateIntentVersionRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(createIntentVersionRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Creates a new version of a slot type based on the $LATEST version of the specified slot type. If
* the $LATEST version of this resource has not changed since the last version that you created,
* Amazon Lex doesn't create a new version. It returns the last version that you created.
*
*
*
* You can update only the $LATEST version of a slot type. You can't update the numbered versions
* that you create with the CreateSlotTypeVersion operation.
*
*
*
* When you create a version of a slot type, Amazon Lex sets the version to 1. Subsequent versions increment by 1.
* For more information, see versioning-intro.
*
*
* This operation requires permissions for the lex:CreateSlotTypeVersion action.
*
*
* @param createSlotTypeVersionRequest
* @return A Java Future containing the result of the CreateSlotTypeVersion operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - ConflictException There was a conflict processing the request. Try your request again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - PreconditionFailedException The checksum of the resource that you are trying to change does not match
* the checksum in the request. Check the resource's checksum and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.CreateSlotTypeVersion
* @see AWS API Documentation
*/
@Override
public CompletableFuture createSlotTypeVersion(
CreateSlotTypeVersionRequest createSlotTypeVersionRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, CreateSlotTypeVersionResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("CreateSlotTypeVersion")
.withMarshaller(new CreateSlotTypeVersionRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(createSlotTypeVersionRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Deletes all versions of the bot, including the $LATEST version. To delete a specific version of
* the bot, use the DeleteBotVersion operation.
*
*
* If a bot has an alias, you can't delete it. Instead, the DeleteBot operation returns a
* ResourceInUseException exception that includes a reference to the alias that refers to the bot. To
* remove the reference to the bot, delete the alias. If you get the same exception again, delete the referring
* alias until the DeleteBot operation is successful.
*
*
* This operation requires permissions for the lex:DeleteBot action.
*
*
* @param deleteBotRequest
* @return A Java Future containing the result of the DeleteBot operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - ConflictException There was a conflict processing the request. Try your request again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - ResourceInUseException The resource that you are attempting to delete is referred to by another
* resource. Use this information to remove references to the resource that you are trying to delete.
*
* The body of the exception contains a JSON object that describes the resource.
*
*
* { "resourceType": BOT | BOTALIAS | BOTCHANNEL | INTENT,
*
*
* "resourceReference": {
*
*
* "name": string, "version": string } }
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.DeleteBot
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture deleteBot(DeleteBotRequest deleteBotRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
DeleteBotResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams().withOperationName("DeleteBot")
.withMarshaller(new DeleteBotRequestMarshaller(protocolFactory)).withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(deleteBotRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Deletes an alias for the specified bot.
*
*
* You can't delete an alias that is used in the association between a bot and a messaging channel. If an alias is
* used in a channel association, the DeleteBot operation returns a ResourceInUseException
* exception that includes a reference to the channel association that refers to the bot. You can remove the
* reference to the alias by deleting the channel association. If you get the same exception again, delete the
* referring association until the DeleteBotAlias operation is successful.
*
*
* @param deleteBotAliasRequest
* @return A Java Future containing the result of the DeleteBotAlias operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - ConflictException There was a conflict processing the request. Try your request again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - ResourceInUseException The resource that you are attempting to delete is referred to by another
* resource. Use this information to remove references to the resource that you are trying to delete.
*
* The body of the exception contains a JSON object that describes the resource.
*
*
* { "resourceType": BOT | BOTALIAS | BOTCHANNEL | INTENT,
*
*
* "resourceReference": {
*
*
* "name": string, "version": string } }
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.DeleteBotAlias
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture deleteBotAlias(DeleteBotAliasRequest deleteBotAliasRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DeleteBotAliasResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DeleteBotAlias")
.withMarshaller(new DeleteBotAliasRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(deleteBotAliasRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Deletes the association between an Amazon Lex bot and a messaging platform.
*
*
* This operation requires permission for the lex:DeleteBotChannelAssociation action.
*
*
* @param deleteBotChannelAssociationRequest
* @return A Java Future containing the result of the DeleteBotChannelAssociation operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - ConflictException There was a conflict processing the request. Try your request again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.DeleteBotChannelAssociation
* @see AWS API Documentation
*/
@Override
public CompletableFuture deleteBotChannelAssociation(
DeleteBotChannelAssociationRequest deleteBotChannelAssociationRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DeleteBotChannelAssociationResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DeleteBotChannelAssociation")
.withMarshaller(new DeleteBotChannelAssociationRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(deleteBotChannelAssociationRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Deletes a specific version of a bot. To delete all versions of a bot, use the DeleteBot operation.
*
*
* This operation requires permissions for the lex:DeleteBotVersion action.
*
*
* @param deleteBotVersionRequest
* @return A Java Future containing the result of the DeleteBotVersion operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - ConflictException There was a conflict processing the request. Try your request again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - ResourceInUseException The resource that you are attempting to delete is referred to by another
* resource. Use this information to remove references to the resource that you are trying to delete.
*
* The body of the exception contains a JSON object that describes the resource.
*
*
* { "resourceType": BOT | BOTALIAS | BOTCHANNEL | INTENT,
*
*
* "resourceReference": {
*
*
* "name": string, "version": string } }
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.DeleteBotVersion
* @see AWS
* API Documentation
*/
@Override
public CompletableFuture deleteBotVersion(DeleteBotVersionRequest deleteBotVersionRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DeleteBotVersionResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DeleteBotVersion")
.withMarshaller(new DeleteBotVersionRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(deleteBotVersionRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Deletes all versions of the intent, including the $LATEST version. To delete a specific version
* of the intent, use the DeleteIntentVersion operation.
*
*
* You can delete a version of an intent only if it is not referenced. To delete an intent that is referred to in
* one or more bots (see how-it-works), you must remove those references first.
*
*
*
* If you get the ResourceInUseException exception, it provides an example reference that shows where
* the intent is referenced. To remove the reference to the intent, either update the bot or delete it. If you get
* the same exception when you attempt to delete the intent again, repeat until the intent has no references and the
* call to DeleteIntent is successful.
*
*
*
* This operation requires permission for the lex:DeleteIntent action.
*
*
* @param deleteIntentRequest
* @return A Java Future containing the result of the DeleteIntent operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - ConflictException There was a conflict processing the request. Try your request again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - ResourceInUseException The resource that you are attempting to delete is referred to by another
* resource. Use this information to remove references to the resource that you are trying to delete.
*
* The body of the exception contains a JSON object that describes the resource.
*
*
* { "resourceType": BOT | BOTALIAS | BOTCHANNEL | INTENT,
*
*
* "resourceReference": {
*
*
* "name": string, "version": string } }
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.DeleteIntent
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture deleteIntent(DeleteIntentRequest deleteIntentRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
DeleteIntentResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DeleteIntent").withMarshaller(new DeleteIntentRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(deleteIntentRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Deletes a specific version of an intent. To delete all versions of a intent, use the DeleteIntent
* operation.
*
*
* This operation requires permissions for the lex:DeleteIntentVersion action.
*
*
* @param deleteIntentVersionRequest
* @return A Java Future containing the result of the DeleteIntentVersion operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - ConflictException There was a conflict processing the request. Try your request again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - ResourceInUseException The resource that you are attempting to delete is referred to by another
* resource. Use this information to remove references to the resource that you are trying to delete.
*
* The body of the exception contains a JSON object that describes the resource.
*
*
* { "resourceType": BOT | BOTALIAS | BOTCHANNEL | INTENT,
*
*
* "resourceReference": {
*
*
* "name": string, "version": string } }
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.DeleteIntentVersion
* @see AWS
* API Documentation
*/
@Override
public CompletableFuture deleteIntentVersion(
DeleteIntentVersionRequest deleteIntentVersionRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DeleteIntentVersionResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DeleteIntentVersion")
.withMarshaller(new DeleteIntentVersionRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(deleteIntentVersionRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Deletes all versions of the slot type, including the $LATEST version. To delete a specific
* version of the slot type, use the DeleteSlotTypeVersion operation.
*
*
* You can delete a version of a slot type only if it is not referenced. To delete a slot type that is referred to
* in one or more intents, you must remove those references first.
*
*
*
* If you get the ResourceInUseException exception, the exception provides an example reference that
* shows the intent where the slot type is referenced. To remove the reference to the slot type, either update the
* intent or delete it. If you get the same exception when you attempt to delete the slot type again, repeat until
* the slot type has no references and the DeleteSlotType call is successful.
*
*
*
* This operation requires permission for the lex:DeleteSlotType action.
*
*
* @param deleteSlotTypeRequest
* @return A Java Future containing the result of the DeleteSlotType operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - ConflictException There was a conflict processing the request. Try your request again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - ResourceInUseException The resource that you are attempting to delete is referred to by another
* resource. Use this information to remove references to the resource that you are trying to delete.
*
* The body of the exception contains a JSON object that describes the resource.
*
*
* { "resourceType": BOT | BOTALIAS | BOTCHANNEL | INTENT,
*
*
* "resourceReference": {
*
*
* "name": string, "version": string } }
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.DeleteSlotType
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture deleteSlotType(DeleteSlotTypeRequest deleteSlotTypeRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DeleteSlotTypeResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DeleteSlotType")
.withMarshaller(new DeleteSlotTypeRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(deleteSlotTypeRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Deletes a specific version of a slot type. To delete all versions of a slot type, use the DeleteSlotType
* operation.
*
*
* This operation requires permissions for the lex:DeleteSlotTypeVersion action.
*
*
* @param deleteSlotTypeVersionRequest
* @return A Java Future containing the result of the DeleteSlotTypeVersion operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - ConflictException There was a conflict processing the request. Try your request again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - ResourceInUseException The resource that you are attempting to delete is referred to by another
* resource. Use this information to remove references to the resource that you are trying to delete.
*
* The body of the exception contains a JSON object that describes the resource.
*
*
* { "resourceType": BOT | BOTALIAS | BOTCHANNEL | INTENT,
*
*
* "resourceReference": {
*
*
* "name": string, "version": string } }
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.DeleteSlotTypeVersion
* @see AWS API Documentation
*/
@Override
public CompletableFuture deleteSlotTypeVersion(
DeleteSlotTypeVersionRequest deleteSlotTypeVersionRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DeleteSlotTypeVersionResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DeleteSlotTypeVersion")
.withMarshaller(new DeleteSlotTypeVersionRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(deleteSlotTypeVersionRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Deletes stored utterances.
*
*
* Amazon Lex stores the utterances that users send to your bot. Utterances are stored for 15 days for use with the
* GetUtterancesView operation, and then stored indefinitely for use in improving the ability of your bot to
* respond to user input.
*
*
* Use the DeleteStoredUtterances operation to manually delete stored utterances for a specific user.
*
*
* This operation requires permissions for the lex:DeleteUtterances action.
*
*
* @param deleteUtterancesRequest
* @return A Java Future containing the result of the DeleteUtterances operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.DeleteUtterances
* @see AWS
* API Documentation
*/
@Override
public CompletableFuture deleteUtterances(DeleteUtterancesRequest deleteUtterancesRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DeleteUtterancesResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DeleteUtterances")
.withMarshaller(new DeleteUtterancesRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(deleteUtterancesRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Returns metadata information for a specific bot. You must provide the bot name and the bot version or alias.
*
*
* This operation requires permissions for the lex:GetBot action.
*
*
* @param getBotRequest
* @return A Java Future containing the result of the GetBot operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetBot
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture getBot(GetBotRequest getBotRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
GetBotResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams().withOperationName("GetBot")
.withMarshaller(new GetBotRequestMarshaller(protocolFactory)).withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(getBotRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Returns information about an Amazon Lex bot alias. For more information about aliases, see
* versioning-aliases.
*
*
* This operation requires permissions for the lex:GetBotAlias action.
*
*
* @param getBotAliasRequest
* @return A Java Future containing the result of the GetBotAlias operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetBotAlias
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture getBotAlias(GetBotAliasRequest getBotAliasRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
GetBotAliasResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("GetBotAlias").withMarshaller(new GetBotAliasRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(getBotAliasRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Returns a list of aliases for a specified Amazon Lex bot.
*
*
* This operation requires permissions for the lex:GetBotAliases action.
*
*
* @param getBotAliasesRequest
* @return A Java Future containing the result of the GetBotAliases operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetBotAliases
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture getBotAliases(GetBotAliasesRequest getBotAliasesRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
GetBotAliasesResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("GetBotAliases")
.withMarshaller(new GetBotAliasesRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(getBotAliasesRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Returns a list of aliases for a specified Amazon Lex bot.
*
*
* This operation requires permissions for the lex:GetBotAliases action.
*
*
*
* This is a variant of
* {@link #getBotAliases(software.amazon.awssdk.services.lexmodelbuilding.model.GetBotAliasesRequest)} operation.
* The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.lexmodelbuilding.paginators.GetBotAliasesPublisher publisher = client.getBotAliasesPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.lexmodelbuilding.paginators.GetBotAliasesPublisher publisher = client.getBotAliasesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.lexmodelbuilding.model.GetBotAliasesResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Note: If you prefer to have control on service calls, use the
* {@link #getBotAliases(software.amazon.awssdk.services.lexmodelbuilding.model.GetBotAliasesRequest)}
* operation.
*
*
* @param getBotAliasesRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetBotAliases
* @see AWS API
* Documentation
*/
public GetBotAliasesPublisher getBotAliasesPaginator(GetBotAliasesRequest getBotAliasesRequest) {
return new GetBotAliasesPublisher(this, applyPaginatorUserAgent(getBotAliasesRequest));
}
/**
*
* Returns information about the association between an Amazon Lex bot and a messaging platform.
*
*
* This operation requires permissions for the lex:GetBotChannelAssociation action.
*
*
* @param getBotChannelAssociationRequest
* @return A Java Future containing the result of the GetBotChannelAssociation operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetBotChannelAssociation
* @see AWS API Documentation
*/
@Override
public CompletableFuture getBotChannelAssociation(
GetBotChannelAssociationRequest getBotChannelAssociationRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, GetBotChannelAssociationResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("GetBotChannelAssociation")
.withMarshaller(new GetBotChannelAssociationRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(getBotChannelAssociationRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Returns a list of all of the channels associated with the specified bot.
*
*
* The GetBotChannelAssociations operation requires permissions for the
* lex:GetBotChannelAssociations action.
*
*
* @param getBotChannelAssociationsRequest
* @return A Java Future containing the result of the GetBotChannelAssociations operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetBotChannelAssociations
* @see AWS API Documentation
*/
@Override
public CompletableFuture getBotChannelAssociations(
GetBotChannelAssociationsRequest getBotChannelAssociationsRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, GetBotChannelAssociationsResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("GetBotChannelAssociations")
.withMarshaller(new GetBotChannelAssociationsRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(getBotChannelAssociationsRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Returns a list of all of the channels associated with the specified bot.
*
*
* The GetBotChannelAssociations operation requires permissions for the
* lex:GetBotChannelAssociations action.
*
*
*
* This is a variant of
* {@link #getBotChannelAssociations(software.amazon.awssdk.services.lexmodelbuilding.model.GetBotChannelAssociationsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.lexmodelbuilding.paginators.GetBotChannelAssociationsPublisher publisher = client.getBotChannelAssociationsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.lexmodelbuilding.paginators.GetBotChannelAssociationsPublisher publisher = client.getBotChannelAssociationsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.lexmodelbuilding.model.GetBotChannelAssociationsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Note: If you prefer to have control on service calls, use the
* {@link #getBotChannelAssociations(software.amazon.awssdk.services.lexmodelbuilding.model.GetBotChannelAssociationsRequest)}
* operation.
*
*
* @param getBotChannelAssociationsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetBotChannelAssociations
* @see AWS API Documentation
*/
public GetBotChannelAssociationsPublisher getBotChannelAssociationsPaginator(
GetBotChannelAssociationsRequest getBotChannelAssociationsRequest) {
return new GetBotChannelAssociationsPublisher(this, applyPaginatorUserAgent(getBotChannelAssociationsRequest));
}
/**
*
* Gets information about all of the versions of a bot.
*
*
* The GetBotVersions operation returns a BotMetadata object for each version of a bot.
* For example, if a bot has three numbered versions, the GetBotVersions operation returns four
* BotMetadata objects in the response, one for each numbered version and one for the
* $LATEST version.
*
*
* The GetBotVersions operation always returns at least one version, the $LATEST
* version.
*
*
* This operation requires permissions for the lex:GetBotVersions action.
*
*
* @param getBotVersionsRequest
* @return A Java Future containing the result of the GetBotVersions operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetBotVersions
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture getBotVersions(GetBotVersionsRequest getBotVersionsRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, GetBotVersionsResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("GetBotVersions")
.withMarshaller(new GetBotVersionsRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(getBotVersionsRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Gets information about all of the versions of a bot.
*
*
* The GetBotVersions operation returns a BotMetadata object for each version of a bot.
* For example, if a bot has three numbered versions, the GetBotVersions operation returns four
* BotMetadata objects in the response, one for each numbered version and one for the
* $LATEST version.
*
*
* The GetBotVersions operation always returns at least one version, the $LATEST
* version.
*
*
* This operation requires permissions for the lex:GetBotVersions action.
*
*
*
* This is a variant of
* {@link #getBotVersions(software.amazon.awssdk.services.lexmodelbuilding.model.GetBotVersionsRequest)} operation.
* The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.lexmodelbuilding.paginators.GetBotVersionsPublisher publisher = client.getBotVersionsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.lexmodelbuilding.paginators.GetBotVersionsPublisher publisher = client.getBotVersionsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.lexmodelbuilding.model.GetBotVersionsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Note: If you prefer to have control on service calls, use the
* {@link #getBotVersions(software.amazon.awssdk.services.lexmodelbuilding.model.GetBotVersionsRequest)}
* operation.
*
*
* @param getBotVersionsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetBotVersions
* @see AWS API
* Documentation
*/
public GetBotVersionsPublisher getBotVersionsPaginator(GetBotVersionsRequest getBotVersionsRequest) {
return new GetBotVersionsPublisher(this, applyPaginatorUserAgent(getBotVersionsRequest));
}
/**
*
* Returns bot information as follows:
*
*
* -
*
* If you provide the nameContains field, the response includes information for the
* $LATEST version of all bots whose name contains the specified string.
*
*
* -
*
* If you don't specify the nameContains field, the operation returns information about the
* $LATEST version of all of your bots.
*
*
*
*
* This operation requires permission for the lex:GetBots action.
*
*
* @param getBotsRequest
* @return A Java Future containing the result of the GetBots operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetBots
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture getBots(GetBotsRequest getBotsRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
GetBotsResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams().withOperationName("GetBots")
.withMarshaller(new GetBotsRequestMarshaller(protocolFactory)).withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(getBotsRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Returns bot information as follows:
*
*
* -
*
* If you provide the nameContains field, the response includes information for the
* $LATEST version of all bots whose name contains the specified string.
*
*
* -
*
* If you don't specify the nameContains field, the operation returns information about the
* $LATEST version of all of your bots.
*
*
*
*
* This operation requires permission for the lex:GetBots action.
*
*
*
* This is a variant of {@link #getBots(software.amazon.awssdk.services.lexmodelbuilding.model.GetBotsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.lexmodelbuilding.paginators.GetBotsPublisher publisher = client.getBotsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.lexmodelbuilding.paginators.GetBotsPublisher publisher = client.getBotsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.lexmodelbuilding.model.GetBotsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Note: If you prefer to have control on service calls, use the
* {@link #getBots(software.amazon.awssdk.services.lexmodelbuilding.model.GetBotsRequest)} operation.
*
*
* @param getBotsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetBots
* @see AWS API
* Documentation
*/
public GetBotsPublisher getBotsPaginator(GetBotsRequest getBotsRequest) {
return new GetBotsPublisher(this, applyPaginatorUserAgent(getBotsRequest));
}
/**
*
* Returns information about a built-in intent.
*
*
* This operation requires permission for the lex:GetBuiltinIntent action.
*
*
* @param getBuiltinIntentRequest
* @return A Java Future containing the result of the GetBuiltinIntent operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetBuiltinIntent
* @see AWS
* API Documentation
*/
@Override
public CompletableFuture getBuiltinIntent(GetBuiltinIntentRequest getBuiltinIntentRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, GetBuiltinIntentResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("GetBuiltinIntent")
.withMarshaller(new GetBuiltinIntentRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(getBuiltinIntentRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Gets a list of built-in intents that meet the specified criteria.
*
*
* This operation requires permission for the lex:GetBuiltinIntents action.
*
*
* @param getBuiltinIntentsRequest
* @return A Java Future containing the result of the GetBuiltinIntents operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetBuiltinIntents
* @see AWS
* API Documentation
*/
@Override
public CompletableFuture getBuiltinIntents(GetBuiltinIntentsRequest getBuiltinIntentsRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, GetBuiltinIntentsResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("GetBuiltinIntents")
.withMarshaller(new GetBuiltinIntentsRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(getBuiltinIntentsRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Gets a list of built-in intents that meet the specified criteria.
*
*
* This operation requires permission for the lex:GetBuiltinIntents action.
*
*
*
* This is a variant of
* {@link #getBuiltinIntents(software.amazon.awssdk.services.lexmodelbuilding.model.GetBuiltinIntentsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.lexmodelbuilding.paginators.GetBuiltinIntentsPublisher publisher = client.getBuiltinIntentsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.lexmodelbuilding.paginators.GetBuiltinIntentsPublisher publisher = client.getBuiltinIntentsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.lexmodelbuilding.model.GetBuiltinIntentsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Note: If you prefer to have control on service calls, use the
* {@link #getBuiltinIntents(software.amazon.awssdk.services.lexmodelbuilding.model.GetBuiltinIntentsRequest)}
* operation.
*
*
* @param getBuiltinIntentsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetBuiltinIntents
* @see AWS
* API Documentation
*/
public GetBuiltinIntentsPublisher getBuiltinIntentsPaginator(GetBuiltinIntentsRequest getBuiltinIntentsRequest) {
return new GetBuiltinIntentsPublisher(this, applyPaginatorUserAgent(getBuiltinIntentsRequest));
}
/**
*
* Gets a list of built-in slot types that meet the specified criteria.
*
*
* For a list of built-in slot types, see Slot Type Reference in the Alexa Skills Kit.
*
*
* This operation requires permission for the lex:GetBuiltInSlotTypes action.
*
*
* @param getBuiltinSlotTypesRequest
* @return A Java Future containing the result of the GetBuiltinSlotTypes operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetBuiltinSlotTypes
* @see AWS
* API Documentation
*/
@Override
public CompletableFuture getBuiltinSlotTypes(
GetBuiltinSlotTypesRequest getBuiltinSlotTypesRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, GetBuiltinSlotTypesResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("GetBuiltinSlotTypes")
.withMarshaller(new GetBuiltinSlotTypesRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(getBuiltinSlotTypesRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Gets a list of built-in slot types that meet the specified criteria.
*
*
* For a list of built-in slot types, see Slot Type Reference in the Alexa Skills Kit.
*
*
* This operation requires permission for the lex:GetBuiltInSlotTypes action.
*
*
*
* This is a variant of
* {@link #getBuiltinSlotTypes(software.amazon.awssdk.services.lexmodelbuilding.model.GetBuiltinSlotTypesRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.lexmodelbuilding.paginators.GetBuiltinSlotTypesPublisher publisher = client.getBuiltinSlotTypesPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.lexmodelbuilding.paginators.GetBuiltinSlotTypesPublisher publisher = client.getBuiltinSlotTypesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.lexmodelbuilding.model.GetBuiltinSlotTypesResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Note: If you prefer to have control on service calls, use the
* {@link #getBuiltinSlotTypes(software.amazon.awssdk.services.lexmodelbuilding.model.GetBuiltinSlotTypesRequest)}
* operation.
*
*
* @param getBuiltinSlotTypesRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetBuiltinSlotTypes
* @see AWS
* API Documentation
*/
public GetBuiltinSlotTypesPublisher getBuiltinSlotTypesPaginator(GetBuiltinSlotTypesRequest getBuiltinSlotTypesRequest) {
return new GetBuiltinSlotTypesPublisher(this, applyPaginatorUserAgent(getBuiltinSlotTypesRequest));
}
/**
*
* Exports the contents of a Amazon Lex resource in a specified format.
*
*
* @param getExportRequest
* @return A Java Future containing the result of the GetExport operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetExport
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture getExport(GetExportRequest getExportRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
GetExportResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams().withOperationName("GetExport")
.withMarshaller(new GetExportRequestMarshaller(protocolFactory)).withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(getExportRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Gets information about an import job started with the StartImport operation.
*
*
* @param getImportRequest
* @return A Java Future containing the result of the GetImport operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetImport
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture getImport(GetImportRequest getImportRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
GetImportResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams().withOperationName("GetImport")
.withMarshaller(new GetImportRequestMarshaller(protocolFactory)).withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(getImportRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Returns information about an intent. In addition to the intent name, you must specify the intent version.
*
*
* This operation requires permissions to perform the lex:GetIntent action.
*
*
* @param getIntentRequest
* @return A Java Future containing the result of the GetIntent operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetIntent
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture getIntent(GetIntentRequest getIntentRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
GetIntentResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams().withOperationName("GetIntent")
.withMarshaller(new GetIntentRequestMarshaller(protocolFactory)).withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(getIntentRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Gets information about all of the versions of an intent.
*
*
* The GetIntentVersions operation returns an IntentMetadata object for each version of an
* intent. For example, if an intent has three numbered versions, the GetIntentVersions operation
* returns four IntentMetadata objects in the response, one for each numbered version and one for the
* $LATEST version.
*
*
* The GetIntentVersions operation always returns at least one version, the $LATEST
* version.
*
*
* This operation requires permissions for the lex:GetIntentVersions action.
*
*
* @param getIntentVersionsRequest
* @return A Java Future containing the result of the GetIntentVersions operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetIntentVersions
* @see AWS
* API Documentation
*/
@Override
public CompletableFuture getIntentVersions(GetIntentVersionsRequest getIntentVersionsRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, GetIntentVersionsResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("GetIntentVersions")
.withMarshaller(new GetIntentVersionsRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(getIntentVersionsRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Gets information about all of the versions of an intent.
*
*
* The GetIntentVersions operation returns an IntentMetadata object for each version of an
* intent. For example, if an intent has three numbered versions, the GetIntentVersions operation
* returns four IntentMetadata objects in the response, one for each numbered version and one for the
* $LATEST version.
*
*
* The GetIntentVersions operation always returns at least one version, the $LATEST
* version.
*
*
* This operation requires permissions for the lex:GetIntentVersions action.
*
*
*
* This is a variant of
* {@link #getIntentVersions(software.amazon.awssdk.services.lexmodelbuilding.model.GetIntentVersionsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.lexmodelbuilding.paginators.GetIntentVersionsPublisher publisher = client.getIntentVersionsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.lexmodelbuilding.paginators.GetIntentVersionsPublisher publisher = client.getIntentVersionsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.lexmodelbuilding.model.GetIntentVersionsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Note: If you prefer to have control on service calls, use the
* {@link #getIntentVersions(software.amazon.awssdk.services.lexmodelbuilding.model.GetIntentVersionsRequest)}
* operation.
*
*
* @param getIntentVersionsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetIntentVersions
* @see AWS
* API Documentation
*/
public GetIntentVersionsPublisher getIntentVersionsPaginator(GetIntentVersionsRequest getIntentVersionsRequest) {
return new GetIntentVersionsPublisher(this, applyPaginatorUserAgent(getIntentVersionsRequest));
}
/**
*
* Returns intent information as follows:
*
*
* -
*
* If you specify the nameContains field, returns the $LATEST version of all intents
* that contain the specified string.
*
*
* -
*
* If you don't specify the nameContains field, returns information about the $LATEST
* version of all intents.
*
*
*
*
* The operation requires permission for the lex:GetIntents action.
*
*
* @param getIntentsRequest
* @return A Java Future containing the result of the GetIntents operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetIntents
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture getIntents(GetIntentsRequest getIntentsRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
GetIntentsResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams().withOperationName("GetIntents")
.withMarshaller(new GetIntentsRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(getIntentsRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Returns intent information as follows:
*
*
* -
*
* If you specify the nameContains field, returns the $LATEST version of all intents
* that contain the specified string.
*
*
* -
*
* If you don't specify the nameContains field, returns information about the $LATEST
* version of all intents.
*
*
*
*
* The operation requires permission for the lex:GetIntents action.
*
*
*
* This is a variant of
* {@link #getIntents(software.amazon.awssdk.services.lexmodelbuilding.model.GetIntentsRequest)} operation. The
* return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.lexmodelbuilding.paginators.GetIntentsPublisher publisher = client.getIntentsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.lexmodelbuilding.paginators.GetIntentsPublisher publisher = client.getIntentsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.lexmodelbuilding.model.GetIntentsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Note: If you prefer to have control on service calls, use the
* {@link #getIntents(software.amazon.awssdk.services.lexmodelbuilding.model.GetIntentsRequest)} operation.
*
*
* @param getIntentsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetIntents
* @see AWS API
* Documentation
*/
public GetIntentsPublisher getIntentsPaginator(GetIntentsRequest getIntentsRequest) {
return new GetIntentsPublisher(this, applyPaginatorUserAgent(getIntentsRequest));
}
/**
*
* Returns information about a specific version of a slot type. In addition to specifying the slot type name, you
* must specify the slot type version.
*
*
* This operation requires permissions for the lex:GetSlotType action.
*
*
* @param getSlotTypeRequest
* @return A Java Future containing the result of the GetSlotType operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetSlotType
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture getSlotType(GetSlotTypeRequest getSlotTypeRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
GetSlotTypeResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("GetSlotType").withMarshaller(new GetSlotTypeRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(getSlotTypeRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Gets information about all versions of a slot type.
*
*
* The GetSlotTypeVersions operation returns a SlotTypeMetadata object for each version of
* a slot type. For example, if a slot type has three numbered versions, the GetSlotTypeVersions
* operation returns four SlotTypeMetadata objects in the response, one for each numbered version and
* one for the $LATEST version.
*
*
* The GetSlotTypeVersions operation always returns at least one version, the $LATEST
* version.
*
*
* This operation requires permissions for the lex:GetSlotTypeVersions action.
*
*
* @param getSlotTypeVersionsRequest
* @return A Java Future containing the result of the GetSlotTypeVersions operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetSlotTypeVersions
* @see AWS
* API Documentation
*/
@Override
public CompletableFuture getSlotTypeVersions(
GetSlotTypeVersionsRequest getSlotTypeVersionsRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, GetSlotTypeVersionsResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("GetSlotTypeVersions")
.withMarshaller(new GetSlotTypeVersionsRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(getSlotTypeVersionsRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Gets information about all versions of a slot type.
*
*
* The GetSlotTypeVersions operation returns a SlotTypeMetadata object for each version of
* a slot type. For example, if a slot type has three numbered versions, the GetSlotTypeVersions
* operation returns four SlotTypeMetadata objects in the response, one for each numbered version and
* one for the $LATEST version.
*
*
* The GetSlotTypeVersions operation always returns at least one version, the $LATEST
* version.
*
*
* This operation requires permissions for the lex:GetSlotTypeVersions action.
*
*
*
* This is a variant of
* {@link #getSlotTypeVersions(software.amazon.awssdk.services.lexmodelbuilding.model.GetSlotTypeVersionsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.lexmodelbuilding.paginators.GetSlotTypeVersionsPublisher publisher = client.getSlotTypeVersionsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.lexmodelbuilding.paginators.GetSlotTypeVersionsPublisher publisher = client.getSlotTypeVersionsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.lexmodelbuilding.model.GetSlotTypeVersionsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Note: If you prefer to have control on service calls, use the
* {@link #getSlotTypeVersions(software.amazon.awssdk.services.lexmodelbuilding.model.GetSlotTypeVersionsRequest)}
* operation.
*
*
* @param getSlotTypeVersionsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetSlotTypeVersions
* @see AWS
* API Documentation
*/
public GetSlotTypeVersionsPublisher getSlotTypeVersionsPaginator(GetSlotTypeVersionsRequest getSlotTypeVersionsRequest) {
return new GetSlotTypeVersionsPublisher(this, applyPaginatorUserAgent(getSlotTypeVersionsRequest));
}
/**
*
* Returns slot type information as follows:
*
*
* -
*
* If you specify the nameContains field, returns the $LATEST version of all slot types
* that contain the specified string.
*
*
* -
*
* If you don't specify the nameContains field, returns information about the $LATEST
* version of all slot types.
*
*
*
*
* The operation requires permission for the lex:GetSlotTypes action.
*
*
* @param getSlotTypesRequest
* @return A Java Future containing the result of the GetSlotTypes operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetSlotTypes
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture getSlotTypes(GetSlotTypesRequest getSlotTypesRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
GetSlotTypesResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("GetSlotTypes").withMarshaller(new GetSlotTypesRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(getSlotTypesRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Returns slot type information as follows:
*
*
* -
*
* If you specify the nameContains field, returns the $LATEST version of all slot types
* that contain the specified string.
*
*
* -
*
* If you don't specify the nameContains field, returns information about the $LATEST
* version of all slot types.
*
*
*
*
* The operation requires permission for the lex:GetSlotTypes action.
*
*
*
* This is a variant of
* {@link #getSlotTypes(software.amazon.awssdk.services.lexmodelbuilding.model.GetSlotTypesRequest)} operation. The
* return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.lexmodelbuilding.paginators.GetSlotTypesPublisher publisher = client.getSlotTypesPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.lexmodelbuilding.paginators.GetSlotTypesPublisher publisher = client.getSlotTypesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.lexmodelbuilding.model.GetSlotTypesResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Note: If you prefer to have control on service calls, use the
* {@link #getSlotTypes(software.amazon.awssdk.services.lexmodelbuilding.model.GetSlotTypesRequest)} operation.
*
*
* @param getSlotTypesRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - NotFoundException The resource specified in the request was not found. Check the resource and try
* again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetSlotTypes
* @see AWS API
* Documentation
*/
public GetSlotTypesPublisher getSlotTypesPaginator(GetSlotTypesRequest getSlotTypesRequest) {
return new GetSlotTypesPublisher(this, applyPaginatorUserAgent(getSlotTypesRequest));
}
/**
*
* Use the GetUtterancesView operation to get information about the utterances that your users have
* made to your bot. You can use this list to tune the utterances that your bot responds to.
*
*
* For example, say that you have created a bot to order flowers. After your users have used your bot for a while,
* use the GetUtterancesView operation to see the requests that they have made and whether they have
* been successful. You might find that the utterance "I want flowers" is not being recognized. You could add this
* utterance to the OrderFlowers intent so that your bot recognizes that utterance.
*
*
* After you publish a new version of a bot, you can get information about the old version and the new so that you
* can compare the performance across the two versions.
*
*
*
* Utterance statistics are generated once a day. Data is available for the last 15 days. You can request
* information for up to 5 versions in each request. The response contains information about a maximum of 100
* utterances for each version.
*
*
*
* This operation requires permissions for the lex:GetUtterancesView action.
*
*
* @param getUtterancesViewRequest
* @return A Java Future containing the result of the GetUtterancesView operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.GetUtterancesView
* @see AWS
* API Documentation
*/
@Override
public CompletableFuture getUtterancesView(GetUtterancesViewRequest getUtterancesViewRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, GetUtterancesViewResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("GetUtterancesView")
.withMarshaller(new GetUtterancesViewRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(getUtterancesViewRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Creates an Amazon Lex conversational bot or replaces an existing bot. When you create or update a bot you are
* only required to specify a name, a locale, and whether the bot is directed toward children under age 13. You can
* use this to add intents later, or to remove intents from an existing bot. When you create a bot with the minimum
* information, the bot is created or updated but Amazon Lex returns the FAILED. You
* can build the bot after you add one or more intents. For more information about Amazon Lex bots, see
* how-it-works.
*
*
* If you specify the name of an existing bot, the fields in the request replace the existing values in the
* $LATEST version of the bot. Amazon Lex removes any fields that you don't provide values for in
* the request, except for the idleTTLInSeconds and privacySettings fields, which are set
* to their default values. If you don't specify values for required fields, Amazon Lex throws an exception.
*
*
* This operation requires permissions for the lex:PutBot action. For more information, see
* auth-and-access-control.
*
*
* @param putBotRequest
* @return A Java Future containing the result of the PutBot operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ConflictException There was a conflict processing the request. Try your request again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - PreconditionFailedException The checksum of the resource that you are trying to change does not match
* the checksum in the request. Check the resource's checksum and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.PutBot
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture putBot(PutBotRequest putBotRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
PutBotResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams().withOperationName("PutBot")
.withMarshaller(new PutBotRequestMarshaller(protocolFactory)).withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(putBotRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Creates an alias for the specified version of the bot or replaces an alias for the specified bot. To change the
* version of the bot that the alias points to, replace the alias. For more information about aliases, see
* versioning-aliases.
*
*
* This operation requires permissions for the lex:PutBotAlias action.
*
*
* @param putBotAliasRequest
* @return A Java Future containing the result of the PutBotAlias operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ConflictException There was a conflict processing the request. Try your request again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - PreconditionFailedException The checksum of the resource that you are trying to change does not match
* the checksum in the request. Check the resource's checksum and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.PutBotAlias
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture putBotAlias(PutBotAliasRequest putBotAliasRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
PutBotAliasResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("PutBotAlias").withMarshaller(new PutBotAliasRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(putBotAliasRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Creates an intent or replaces an existing intent.
*
*
* To define the interaction between the user and your bot, you use one or more intents. For a pizza ordering bot,
* for example, you would create an OrderPizza intent.
*
*
* To create an intent or replace an existing intent, you must provide the following:
*
*
* -
*
* Intent name. For example, OrderPizza.
*
*
* -
*
* Sample utterances. For example, "Can I order a pizza, please." and "I want to order a pizza."
*
*
* -
*
* Information to be gathered. You specify slot types for the information that your bot will request from the user.
* You can specify standard slot types, such as a date or a time, or custom slot types such as the size and crust of
* a pizza.
*
*
* -
*
* How the intent will be fulfilled. You can provide a Lambda function or configure the intent to return the intent
* information to the client application. If you use a Lambda function, when all of the intent information is
* available, Amazon Lex invokes your Lambda function. If you configure your intent to return the intent information
* to the client application.
*
*
*
*
* You can specify other optional information in the request, such as:
*
*
* -
*
* A confirmation prompt to ask the user to confirm an intent. For example, "Shall I order your pizza?"
*
*
* -
*
* A conclusion statement to send to the user after the intent has been fulfilled. For example,
* "I placed your pizza order."
*
*
* -
*
* A follow-up prompt that asks the user for additional activity. For example, asking
* "Do you want to order a drink with your pizza?"
*
*
*
*
* If you specify an existing intent name to update the intent, Amazon Lex replaces the values in the
* $LATEST version of the intent with the values in the request. Amazon Lex removes fields that you
* don't provide in the request. If you don't specify the required fields, Amazon Lex throws an exception. When you
* update the $LATEST version of an intent, the status field of any bot that uses the
* $LATEST version of the intent is set to NOT_BUILT.
*
*
* For more information, see how-it-works.
*
*
* This operation requires permissions for the lex:PutIntent action.
*
*
* @param putIntentRequest
* @return A Java Future containing the result of the PutIntent operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ConflictException There was a conflict processing the request. Try your request again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - PreconditionFailedException The checksum of the resource that you are trying to change does not match
* the checksum in the request. Check the resource's checksum and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.PutIntent
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture putIntent(PutIntentRequest putIntentRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
PutIntentResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams().withOperationName("PutIntent")
.withMarshaller(new PutIntentRequestMarshaller(protocolFactory)).withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(putIntentRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Creates a custom slot type or replaces an existing custom slot type.
*
*
* To create a custom slot type, specify a name for the slot type and a set of enumeration values, which are the
* values that a slot of this type can assume. For more information, see how-it-works.
*
*
* If you specify the name of an existing slot type, the fields in the request replace the existing values in the
* $LATEST version of the slot type. Amazon Lex removes the fields that you don't provide in the
* request. If you don't specify required fields, Amazon Lex throws an exception. When you update the
* $LATEST version of a slot type, if a bot uses the $LATEST version of an intent
* that contains the slot type, the bot's status field is set to NOT_BUILT.
*
*
* This operation requires permissions for the lex:PutSlotType action.
*
*
* @param putSlotTypeRequest
* @return A Java Future containing the result of the PutSlotType operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ConflictException There was a conflict processing the request. Try your request again.
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - PreconditionFailedException The checksum of the resource that you are trying to change does not match
* the checksum in the request. Check the resource's checksum and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.PutSlotType
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture putSlotType(PutSlotTypeRequest putSlotTypeRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
PutSlotTypeResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("PutSlotType").withMarshaller(new PutSlotTypeRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(putSlotTypeRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Starts a job to import a resource to Amazon Lex.
*
*
* @param startImportRequest
* @return A Java Future containing the result of the StartImport operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - LimitExceededException The request exceeded a limit. Try your request again.
* - InternalFailureException An internal Amazon Lex error occurred. Try your request again.
* - BadRequestException The request is not well formed. For example, a value is invalid or a required
* field is missing. Check the field values, and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - LexModelBuildingException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample LexModelBuildingAsyncClient.StartImport
* @see AWS API
* Documentation
*/
@Override
public CompletableFuture startImport(StartImportRequest startImportRequest) {
try {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
StartImportResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("StartImport").withMarshaller(new StartImportRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withInput(startImportRequest));
return executeFuture;
} catch (Throwable t) {
return CompletableFutureUtils.failedFuture(t);
}
}
@Override
public void close() {
clientHandler.close();
}
private > T init(T builder) {
return builder
.clientConfiguration(clientConfiguration)
.defaultServiceExceptionSupplier(LexModelBuildingException::builder)
.protocol(AwsJsonProtocol.REST_JSON)
.protocolVersion("1.1")
.registerModeledException(
ExceptionMetadata.builder().errorCode("InternalFailureException")
.exceptionBuilderSupplier(InternalFailureException::builder).httpStatusCode(500).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("ResourceInUseException")
.exceptionBuilderSupplier(ResourceInUseException::builder).httpStatusCode(400).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("NotFoundException")
.exceptionBuilderSupplier(NotFoundException::builder).httpStatusCode(404).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("LimitExceededException")
.exceptionBuilderSupplier(LimitExceededException::builder).httpStatusCode(429).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("ConflictException")
.exceptionBuilderSupplier(ConflictException::builder).httpStatusCode(409).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("PreconditionFailedException")
.exceptionBuilderSupplier(PreconditionFailedException::builder).httpStatusCode(412).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("BadRequestException")
.exceptionBuilderSupplier(BadRequestException::builder).httpStatusCode(400).build());
}
private T applyPaginatorUserAgent(T request) {
Consumer userAgentApplier = b -> b.addApiName(ApiName.builder()
.version(VersionInfo.SDK_VERSION).name("PAGINATED").build());
AwsRequestOverrideConfiguration overrideConfiguration = request.overrideConfiguration()
.map(c -> c.toBuilder().applyMutation(userAgentApplier).build())
.orElse((AwsRequestOverrideConfiguration.builder().applyMutation(userAgentApplier).build()));
return (T) request.toBuilder().overrideConfiguration(overrideConfiguration).build();
}
private HttpResponseHandler createErrorResponseHandler(BaseAwsJsonProtocolFactory protocolFactory,
JsonOperationMetadata operationMetadata) {
return protocolFactory.createErrorResponseHandler(operationMetadata);
}
}