com.amazonaws.services.lexmodelbuilding.AmazonLexModelBuildingClient Maven / Gradle / Ivy
/*
* Copyright 2015-2020 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 com.amazonaws.services.lexmodelbuilding;
import org.w3c.dom.*;
import java.net.*;
import java.util.*;
import javax.annotation.Generated;
import org.apache.commons.logging.*;
import com.amazonaws.*;
import com.amazonaws.annotation.SdkInternalApi;
import com.amazonaws.auth.*;
import com.amazonaws.handlers.*;
import com.amazonaws.http.*;
import com.amazonaws.internal.*;
import com.amazonaws.internal.auth.*;
import com.amazonaws.metrics.*;
import com.amazonaws.regions.*;
import com.amazonaws.transform.*;
import com.amazonaws.util.*;
import com.amazonaws.protocol.json.*;
import com.amazonaws.util.AWSRequestMetrics.Field;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.client.AwsSyncClientParams;
import com.amazonaws.client.builder.AdvancedConfig;
import com.amazonaws.services.lexmodelbuilding.AmazonLexModelBuildingClientBuilder;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.lexmodelbuilding.model.*;
import com.amazonaws.services.lexmodelbuilding.model.transform.*;
/**
* Client for accessing Amazon Lex Model Building Service. All service calls made using this client are blocking, and
* will not return until the service call completes.
*
* Amazon Lex Build-Time Actions
*
* Amazon Lex is an AWS service for building conversational voice and text interfaces. Use these actions to create,
* update, and delete conversational bots for new and existing client applications.
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AmazonLexModelBuildingClient extends AmazonWebServiceClient implements AmazonLexModelBuilding {
/** Provider for AWS credentials. */
private final AWSCredentialsProvider awsCredentialsProvider;
private static final Log log = LogFactory.getLog(AmazonLexModelBuilding.class);
/** Default signing name for the service. */
private static final String DEFAULT_SIGNING_NAME = "lex";
/** Client configuration factory providing ClientConfigurations tailored to this client */
protected static final ClientConfigurationFactory configFactory = new ClientConfigurationFactory();
private final AdvancedConfig advancedConfig;
private static final com.amazonaws.protocol.json.SdkJsonProtocolFactory protocolFactory = new com.amazonaws.protocol.json.SdkJsonProtocolFactory(
new JsonClientMetadata()
.withProtocolVersion("1.1")
.withSupportsCbor(false)
.withSupportsIon(false)
.withContentTypeOverride("")
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InternalFailureException").withExceptionUnmarshaller(
com.amazonaws.services.lexmodelbuilding.model.transform.InternalFailureExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceInUseException").withExceptionUnmarshaller(
com.amazonaws.services.lexmodelbuilding.model.transform.ResourceInUseExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("NotFoundException").withExceptionUnmarshaller(
com.amazonaws.services.lexmodelbuilding.model.transform.NotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("LimitExceededException").withExceptionUnmarshaller(
com.amazonaws.services.lexmodelbuilding.model.transform.LimitExceededExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ConflictException").withExceptionUnmarshaller(
com.amazonaws.services.lexmodelbuilding.model.transform.ConflictExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("PreconditionFailedException").withExceptionUnmarshaller(
com.amazonaws.services.lexmodelbuilding.model.transform.PreconditionFailedExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("BadRequestException").withExceptionUnmarshaller(
com.amazonaws.services.lexmodelbuilding.model.transform.BadRequestExceptionUnmarshaller.getInstance()))
.withBaseServiceExceptionClass(com.amazonaws.services.lexmodelbuilding.model.AmazonLexModelBuildingException.class));
public static AmazonLexModelBuildingClientBuilder builder() {
return AmazonLexModelBuildingClientBuilder.standard();
}
/**
* Constructs a new client to invoke service methods on Amazon Lex Model Building Service using the specified
* parameters.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonLexModelBuildingClient(AwsSyncClientParams clientParams) {
this(clientParams, false);
}
/**
* Constructs a new client to invoke service methods on Amazon Lex Model Building Service using the specified
* parameters.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonLexModelBuildingClient(AwsSyncClientParams clientParams, boolean endpointDiscoveryEnabled) {
super(clientParams);
this.awsCredentialsProvider = clientParams.getCredentialsProvider();
this.advancedConfig = clientParams.getAdvancedConfig();
init();
}
private void init() {
setServiceNameIntern(DEFAULT_SIGNING_NAME);
setEndpointPrefix(ENDPOINT_PREFIX);
// calling this.setEndPoint(...) will also modify the signer accordingly
setEndpoint("models.lex.us-east-1.amazonaws.com");
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s.addAll(chainFactory.newRequestHandlerChain("/com/amazonaws/services/lexmodelbuilding/request.handlers"));
requestHandler2s.addAll(chainFactory.newRequestHandler2Chain("/com/amazonaws/services/lexmodelbuilding/request.handler2s"));
requestHandler2s.addAll(chainFactory.getGlobalHandlers());
}
/**
*
* 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 Result of the CreateBotVersion operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws ConflictException
* There was a conflict processing the request. Try your request again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @throws 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.
* @sample AmazonLexModelBuilding.CreateBotVersion
* @see AWS
* API Documentation
*/
@Override
public CreateBotVersionResult createBotVersion(CreateBotVersionRequest request) {
request = beforeClientExecution(request);
return executeCreateBotVersion(request);
}
@SdkInternalApi
final CreateBotVersionResult executeCreateBotVersion(CreateBotVersionRequest createBotVersionRequest) {
ExecutionContext executionContext = createExecutionContext(createBotVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateBotVersionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createBotVersionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateBotVersion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateBotVersionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the CreateIntentVersion operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws ConflictException
* There was a conflict processing the request. Try your request again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @throws 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.
* @sample AmazonLexModelBuilding.CreateIntentVersion
* @see AWS
* API Documentation
*/
@Override
public CreateIntentVersionResult createIntentVersion(CreateIntentVersionRequest request) {
request = beforeClientExecution(request);
return executeCreateIntentVersion(request);
}
@SdkInternalApi
final CreateIntentVersionResult executeCreateIntentVersion(CreateIntentVersionRequest createIntentVersionRequest) {
ExecutionContext executionContext = createExecutionContext(createIntentVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateIntentVersionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createIntentVersionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateIntentVersion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateIntentVersionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the CreateSlotTypeVersion operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws ConflictException
* There was a conflict processing the request. Try your request again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @throws 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.
* @sample AmazonLexModelBuilding.CreateSlotTypeVersion
* @see AWS API Documentation
*/
@Override
public CreateSlotTypeVersionResult createSlotTypeVersion(CreateSlotTypeVersionRequest request) {
request = beforeClientExecution(request);
return executeCreateSlotTypeVersion(request);
}
@SdkInternalApi
final CreateSlotTypeVersionResult executeCreateSlotTypeVersion(CreateSlotTypeVersionRequest createSlotTypeVersionRequest) {
ExecutionContext executionContext = createExecutionContext(createSlotTypeVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateSlotTypeVersionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createSlotTypeVersionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateSlotTypeVersion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateSlotTypeVersionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes all versions of the bot, including the $LATEST version. To delete a specific version of the
* bot, use the DeleteBotVersion operation. The DeleteBot operation doesn't immediately remove
* the bot schema. Instead, it is marked for deletion and removed later.
*
*
* Amazon Lex stores utterances indefinitely for improving the ability of your bot to respond to user inputs. These
* utterances are not removed when the bot is deleted. To remove the utterances, use the DeleteUtterances
* 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 Result of the DeleteBot operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws ConflictException
* There was a conflict processing the request. Try your request again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @throws 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 } }
* @sample AmazonLexModelBuilding.DeleteBot
* @see AWS API
* Documentation
*/
@Override
public DeleteBotResult deleteBot(DeleteBotRequest request) {
request = beforeClientExecution(request);
return executeDeleteBot(request);
}
@SdkInternalApi
final DeleteBotResult executeDeleteBot(DeleteBotRequest deleteBotRequest) {
ExecutionContext executionContext = createExecutionContext(deleteBotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteBotRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteBotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteBot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteBotResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the DeleteBotAlias operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws ConflictException
* There was a conflict processing the request. Try your request again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @throws 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 } }
* @sample AmazonLexModelBuilding.DeleteBotAlias
* @see AWS API
* Documentation
*/
@Override
public DeleteBotAliasResult deleteBotAlias(DeleteBotAliasRequest request) {
request = beforeClientExecution(request);
return executeDeleteBotAlias(request);
}
@SdkInternalApi
final DeleteBotAliasResult executeDeleteBotAlias(DeleteBotAliasRequest deleteBotAliasRequest) {
ExecutionContext executionContext = createExecutionContext(deleteBotAliasRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteBotAliasRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteBotAliasRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteBotAlias");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteBotAliasResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the association between an Amazon Lex bot and a messaging platform.
*
*
* This operation requires permission for the lex:DeleteBotChannelAssociation action.
*
*
* @param deleteBotChannelAssociationRequest
* @return Result of the DeleteBotChannelAssociation operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws ConflictException
* There was a conflict processing the request. Try your request again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.DeleteBotChannelAssociation
* @see AWS API Documentation
*/
@Override
public DeleteBotChannelAssociationResult deleteBotChannelAssociation(DeleteBotChannelAssociationRequest request) {
request = beforeClientExecution(request);
return executeDeleteBotChannelAssociation(request);
}
@SdkInternalApi
final DeleteBotChannelAssociationResult executeDeleteBotChannelAssociation(DeleteBotChannelAssociationRequest deleteBotChannelAssociationRequest) {
ExecutionContext executionContext = createExecutionContext(deleteBotChannelAssociationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteBotChannelAssociationRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteBotChannelAssociationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteBotChannelAssociation");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteBotChannelAssociationResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the DeleteBotVersion operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws ConflictException
* There was a conflict processing the request. Try your request again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @throws 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 } }
* @sample AmazonLexModelBuilding.DeleteBotVersion
* @see AWS
* API Documentation
*/
@Override
public DeleteBotVersionResult deleteBotVersion(DeleteBotVersionRequest request) {
request = beforeClientExecution(request);
return executeDeleteBotVersion(request);
}
@SdkInternalApi
final DeleteBotVersionResult executeDeleteBotVersion(DeleteBotVersionRequest deleteBotVersionRequest) {
ExecutionContext executionContext = createExecutionContext(deleteBotVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteBotVersionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteBotVersionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteBotVersion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteBotVersionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the DeleteIntent operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws ConflictException
* There was a conflict processing the request. Try your request again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @throws 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 } }
* @sample AmazonLexModelBuilding.DeleteIntent
* @see AWS API
* Documentation
*/
@Override
public DeleteIntentResult deleteIntent(DeleteIntentRequest request) {
request = beforeClientExecution(request);
return executeDeleteIntent(request);
}
@SdkInternalApi
final DeleteIntentResult executeDeleteIntent(DeleteIntentRequest deleteIntentRequest) {
ExecutionContext executionContext = createExecutionContext(deleteIntentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteIntentRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteIntentRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteIntent");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteIntentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the DeleteIntentVersion operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws ConflictException
* There was a conflict processing the request. Try your request again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @throws 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 } }
* @sample AmazonLexModelBuilding.DeleteIntentVersion
* @see AWS
* API Documentation
*/
@Override
public DeleteIntentVersionResult deleteIntentVersion(DeleteIntentVersionRequest request) {
request = beforeClientExecution(request);
return executeDeleteIntentVersion(request);
}
@SdkInternalApi
final DeleteIntentVersionResult executeDeleteIntentVersion(DeleteIntentVersionRequest deleteIntentVersionRequest) {
ExecutionContext executionContext = createExecutionContext(deleteIntentVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteIntentVersionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteIntentVersionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteIntentVersion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteIntentVersionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the DeleteSlotType operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws ConflictException
* There was a conflict processing the request. Try your request again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @throws 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 } }
* @sample AmazonLexModelBuilding.DeleteSlotType
* @see AWS API
* Documentation
*/
@Override
public DeleteSlotTypeResult deleteSlotType(DeleteSlotTypeRequest request) {
request = beforeClientExecution(request);
return executeDeleteSlotType(request);
}
@SdkInternalApi
final DeleteSlotTypeResult executeDeleteSlotType(DeleteSlotTypeRequest deleteSlotTypeRequest) {
ExecutionContext executionContext = createExecutionContext(deleteSlotTypeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteSlotTypeRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteSlotTypeRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteSlotType");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteSlotTypeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the DeleteSlotTypeVersion operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws ConflictException
* There was a conflict processing the request. Try your request again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @throws 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 } }
* @sample AmazonLexModelBuilding.DeleteSlotTypeVersion
* @see AWS API Documentation
*/
@Override
public DeleteSlotTypeVersionResult deleteSlotTypeVersion(DeleteSlotTypeVersionRequest request) {
request = beforeClientExecution(request);
return executeDeleteSlotTypeVersion(request);
}
@SdkInternalApi
final DeleteSlotTypeVersionResult executeDeleteSlotTypeVersion(DeleteSlotTypeVersionRequest deleteSlotTypeVersionRequest) {
ExecutionContext executionContext = createExecutionContext(deleteSlotTypeVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteSlotTypeVersionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteSlotTypeVersionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteSlotTypeVersion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteSlotTypeVersionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 DeleteUtterances operation to manually delete stored utterances for a specific user. When
* you use the DeleteUtterances operation, utterances stored for improving your bot's ability to
* respond to user input are deleted immediately. Utterances stored for use with the GetUtterancesView
* operation are deleted after 15 days.
*
*
* This operation requires permissions for the lex:DeleteUtterances action.
*
*
* @param deleteUtterancesRequest
* @return Result of the DeleteUtterances operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.DeleteUtterances
* @see AWS
* API Documentation
*/
@Override
public DeleteUtterancesResult deleteUtterances(DeleteUtterancesRequest request) {
request = beforeClientExecution(request);
return executeDeleteUtterances(request);
}
@SdkInternalApi
final DeleteUtterancesResult executeDeleteUtterances(DeleteUtterancesRequest deleteUtterancesRequest) {
ExecutionContext executionContext = createExecutionContext(deleteUtterancesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteUtterancesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteUtterancesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteUtterances");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteUtterancesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the GetBot operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.GetBot
* @see AWS API
* Documentation
*/
@Override
public GetBotResult getBot(GetBotRequest request) {
request = beforeClientExecution(request);
return executeGetBot(request);
}
@SdkInternalApi
final GetBotResult executeGetBot(GetBotRequest getBotRequest) {
ExecutionContext executionContext = createExecutionContext(getBotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetBotRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getBotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetBot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetBotResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the GetBotAlias operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.GetBotAlias
* @see AWS API
* Documentation
*/
@Override
public GetBotAliasResult getBotAlias(GetBotAliasRequest request) {
request = beforeClientExecution(request);
return executeGetBotAlias(request);
}
@SdkInternalApi
final GetBotAliasResult executeGetBotAlias(GetBotAliasRequest getBotAliasRequest) {
ExecutionContext executionContext = createExecutionContext(getBotAliasRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetBotAliasRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getBotAliasRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetBotAlias");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetBotAliasResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of aliases for a specified Amazon Lex bot.
*
*
* This operation requires permissions for the lex:GetBotAliases action.
*
*
* @param getBotAliasesRequest
* @return Result of the GetBotAliases operation returned by the service.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.GetBotAliases
* @see AWS API
* Documentation
*/
@Override
public GetBotAliasesResult getBotAliases(GetBotAliasesRequest request) {
request = beforeClientExecution(request);
return executeGetBotAliases(request);
}
@SdkInternalApi
final GetBotAliasesResult executeGetBotAliases(GetBotAliasesRequest getBotAliasesRequest) {
ExecutionContext executionContext = createExecutionContext(getBotAliasesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetBotAliasesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getBotAliasesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetBotAliases");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetBotAliasesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the GetBotChannelAssociation operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.GetBotChannelAssociation
* @see AWS API Documentation
*/
@Override
public GetBotChannelAssociationResult getBotChannelAssociation(GetBotChannelAssociationRequest request) {
request = beforeClientExecution(request);
return executeGetBotChannelAssociation(request);
}
@SdkInternalApi
final GetBotChannelAssociationResult executeGetBotChannelAssociation(GetBotChannelAssociationRequest getBotChannelAssociationRequest) {
ExecutionContext executionContext = createExecutionContext(getBotChannelAssociationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetBotChannelAssociationRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(getBotChannelAssociationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetBotChannelAssociation");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new GetBotChannelAssociationResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the GetBotChannelAssociations operation returned by the service.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.GetBotChannelAssociations
* @see AWS API Documentation
*/
@Override
public GetBotChannelAssociationsResult getBotChannelAssociations(GetBotChannelAssociationsRequest request) {
request = beforeClientExecution(request);
return executeGetBotChannelAssociations(request);
}
@SdkInternalApi
final GetBotChannelAssociationsResult executeGetBotChannelAssociations(GetBotChannelAssociationsRequest getBotChannelAssociationsRequest) {
ExecutionContext executionContext = createExecutionContext(getBotChannelAssociationsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetBotChannelAssociationsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(getBotChannelAssociationsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetBotChannelAssociations");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new GetBotChannelAssociationsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the GetBotVersions operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.GetBotVersions
* @see AWS API
* Documentation
*/
@Override
public GetBotVersionsResult getBotVersions(GetBotVersionsRequest request) {
request = beforeClientExecution(request);
return executeGetBotVersions(request);
}
@SdkInternalApi
final GetBotVersionsResult executeGetBotVersions(GetBotVersionsRequest getBotVersionsRequest) {
ExecutionContext executionContext = createExecutionContext(getBotVersionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetBotVersionsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getBotVersionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetBotVersions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetBotVersionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the GetBots operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.GetBots
* @see AWS API
* Documentation
*/
@Override
public GetBotsResult getBots(GetBotsRequest request) {
request = beforeClientExecution(request);
return executeGetBots(request);
}
@SdkInternalApi
final GetBotsResult executeGetBots(GetBotsRequest getBotsRequest) {
ExecutionContext executionContext = createExecutionContext(getBotsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetBotsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getBotsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetBots");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetBotsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns information about a built-in intent.
*
*
* This operation requires permission for the lex:GetBuiltinIntent action.
*
*
* @param getBuiltinIntentRequest
* @return Result of the GetBuiltinIntent operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.GetBuiltinIntent
* @see AWS
* API Documentation
*/
@Override
public GetBuiltinIntentResult getBuiltinIntent(GetBuiltinIntentRequest request) {
request = beforeClientExecution(request);
return executeGetBuiltinIntent(request);
}
@SdkInternalApi
final GetBuiltinIntentResult executeGetBuiltinIntent(GetBuiltinIntentRequest getBuiltinIntentRequest) {
ExecutionContext executionContext = createExecutionContext(getBuiltinIntentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetBuiltinIntentRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getBuiltinIntentRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetBuiltinIntent");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetBuiltinIntentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Gets a list of built-in intents that meet the specified criteria.
*
*
* This operation requires permission for the lex:GetBuiltinIntents action.
*
*
* @param getBuiltinIntentsRequest
* @return Result of the GetBuiltinIntents operation returned by the service.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.GetBuiltinIntents
* @see AWS
* API Documentation
*/
@Override
public GetBuiltinIntentsResult getBuiltinIntents(GetBuiltinIntentsRequest request) {
request = beforeClientExecution(request);
return executeGetBuiltinIntents(request);
}
@SdkInternalApi
final GetBuiltinIntentsResult executeGetBuiltinIntents(GetBuiltinIntentsRequest getBuiltinIntentsRequest) {
ExecutionContext executionContext = createExecutionContext(getBuiltinIntentsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetBuiltinIntentsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getBuiltinIntentsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetBuiltinIntents");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetBuiltinIntentsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the GetBuiltinSlotTypes operation returned by the service.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.GetBuiltinSlotTypes
* @see AWS
* API Documentation
*/
@Override
public GetBuiltinSlotTypesResult getBuiltinSlotTypes(GetBuiltinSlotTypesRequest request) {
request = beforeClientExecution(request);
return executeGetBuiltinSlotTypes(request);
}
@SdkInternalApi
final GetBuiltinSlotTypesResult executeGetBuiltinSlotTypes(GetBuiltinSlotTypesRequest getBuiltinSlotTypesRequest) {
ExecutionContext executionContext = createExecutionContext(getBuiltinSlotTypesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetBuiltinSlotTypesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getBuiltinSlotTypesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetBuiltinSlotTypes");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetBuiltinSlotTypesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Exports the contents of a Amazon Lex resource in a specified format.
*
*
* @param getExportRequest
* @return Result of the GetExport operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.GetExport
* @see AWS API
* Documentation
*/
@Override
public GetExportResult getExport(GetExportRequest request) {
request = beforeClientExecution(request);
return executeGetExport(request);
}
@SdkInternalApi
final GetExportResult executeGetExport(GetExportRequest getExportRequest) {
ExecutionContext executionContext = createExecutionContext(getExportRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetExportRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getExportRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetExport");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetExportResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Gets information about an import job started with the StartImport operation.
*
*
* @param getImportRequest
* @return Result of the GetImport operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.GetImport
* @see AWS API
* Documentation
*/
@Override
public GetImportResult getImport(GetImportRequest request) {
request = beforeClientExecution(request);
return executeGetImport(request);
}
@SdkInternalApi
final GetImportResult executeGetImport(GetImportRequest getImportRequest) {
ExecutionContext executionContext = createExecutionContext(getImportRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetImportRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getImportRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetImport");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetImportResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the GetIntent operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.GetIntent
* @see AWS API
* Documentation
*/
@Override
public GetIntentResult getIntent(GetIntentRequest request) {
request = beforeClientExecution(request);
return executeGetIntent(request);
}
@SdkInternalApi
final GetIntentResult executeGetIntent(GetIntentRequest getIntentRequest) {
ExecutionContext executionContext = createExecutionContext(getIntentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetIntentRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getIntentRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetIntent");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetIntentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the GetIntentVersions operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.GetIntentVersions
* @see AWS
* API Documentation
*/
@Override
public GetIntentVersionsResult getIntentVersions(GetIntentVersionsRequest request) {
request = beforeClientExecution(request);
return executeGetIntentVersions(request);
}
@SdkInternalApi
final GetIntentVersionsResult executeGetIntentVersions(GetIntentVersionsRequest getIntentVersionsRequest) {
ExecutionContext executionContext = createExecutionContext(getIntentVersionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetIntentVersionsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getIntentVersionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetIntentVersions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetIntentVersionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the GetIntents operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.GetIntents
* @see AWS API
* Documentation
*/
@Override
public GetIntentsResult getIntents(GetIntentsRequest request) {
request = beforeClientExecution(request);
return executeGetIntents(request);
}
@SdkInternalApi
final GetIntentsResult executeGetIntents(GetIntentsRequest getIntentsRequest) {
ExecutionContext executionContext = createExecutionContext(getIntentsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetIntentsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getIntentsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetIntents");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetIntentsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the GetSlotType operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.GetSlotType
* @see AWS API
* Documentation
*/
@Override
public GetSlotTypeResult getSlotType(GetSlotTypeRequest request) {
request = beforeClientExecution(request);
return executeGetSlotType(request);
}
@SdkInternalApi
final GetSlotTypeResult executeGetSlotType(GetSlotTypeRequest getSlotTypeRequest) {
ExecutionContext executionContext = createExecutionContext(getSlotTypeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetSlotTypeRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getSlotTypeRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetSlotType");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetSlotTypeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the GetSlotTypeVersions operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.GetSlotTypeVersions
* @see AWS
* API Documentation
*/
@Override
public GetSlotTypeVersionsResult getSlotTypeVersions(GetSlotTypeVersionsRequest request) {
request = beforeClientExecution(request);
return executeGetSlotTypeVersions(request);
}
@SdkInternalApi
final GetSlotTypeVersionsResult executeGetSlotTypeVersions(GetSlotTypeVersionsRequest getSlotTypeVersionsRequest) {
ExecutionContext executionContext = createExecutionContext(getSlotTypeVersionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetSlotTypeVersionsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getSlotTypeVersionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetSlotTypeVersions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetSlotTypeVersionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the GetSlotTypes operation returned by the service.
* @throws NotFoundException
* The resource specified in the request was not found. Check the resource and try again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.GetSlotTypes
* @see AWS API
* Documentation
*/
@Override
public GetSlotTypesResult getSlotTypes(GetSlotTypesRequest request) {
request = beforeClientExecution(request);
return executeGetSlotTypes(request);
}
@SdkInternalApi
final GetSlotTypesResult executeGetSlotTypes(GetSlotTypesRequest getSlotTypesRequest) {
ExecutionContext executionContext = createExecutionContext(getSlotTypesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetSlotTypesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getSlotTypesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetSlotTypes");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetSlotTypesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 of your bot in each request. Amazon Lex returns the most frequent utterances
* received by the bot in the last 15 days. The response contains information about a maximum of 100 utterances for
* each version.
*
*
* If you set childDirected field to true when you created your bot, or if you opted out of
* participating in improving Amazon Lex, utterances are not available.
*
*
* This operation requires permissions for the lex:GetUtterancesView action.
*
*
* @param getUtterancesViewRequest
* @return Result of the GetUtterancesView operation returned by the service.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.GetUtterancesView
* @see AWS
* API Documentation
*/
@Override
public GetUtterancesViewResult getUtterancesView(GetUtterancesViewRequest request) {
request = beforeClientExecution(request);
return executeGetUtterancesView(request);
}
@SdkInternalApi
final GetUtterancesViewResult executeGetUtterancesView(GetUtterancesViewRequest getUtterancesViewRequest) {
ExecutionContext executionContext = createExecutionContext(getUtterancesViewRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetUtterancesViewRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getUtterancesViewRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetUtterancesView");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetUtterancesViewResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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
* security-iam.
*
*
* @param putBotRequest
* @return Result of the PutBot operation returned by the service.
* @throws ConflictException
* There was a conflict processing the request. Try your request again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @throws 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.
* @sample AmazonLexModelBuilding.PutBot
* @see AWS API
* Documentation
*/
@Override
public PutBotResult putBot(PutBotRequest request) {
request = beforeClientExecution(request);
return executePutBot(request);
}
@SdkInternalApi
final PutBotResult executePutBot(PutBotRequest putBotRequest) {
ExecutionContext executionContext = createExecutionContext(putBotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new PutBotRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(putBotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "PutBot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new PutBotResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the PutBotAlias operation returned by the service.
* @throws ConflictException
* There was a conflict processing the request. Try your request again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @throws 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.
* @sample AmazonLexModelBuilding.PutBotAlias
* @see AWS API
* Documentation
*/
@Override
public PutBotAliasResult putBotAlias(PutBotAliasRequest request) {
request = beforeClientExecution(request);
return executePutBotAlias(request);
}
@SdkInternalApi
final PutBotAliasResult executePutBotAlias(PutBotAliasRequest putBotAliasRequest) {
ExecutionContext executionContext = createExecutionContext(putBotAliasRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new PutBotAliasRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(putBotAliasRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "PutBotAlias");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new PutBotAliasResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the PutIntent operation returned by the service.
* @throws ConflictException
* There was a conflict processing the request. Try your request again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @throws 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.
* @sample AmazonLexModelBuilding.PutIntent
* @see AWS API
* Documentation
*/
@Override
public PutIntentResult putIntent(PutIntentRequest request) {
request = beforeClientExecution(request);
return executePutIntent(request);
}
@SdkInternalApi
final PutIntentResult executePutIntent(PutIntentRequest putIntentRequest) {
ExecutionContext executionContext = createExecutionContext(putIntentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new PutIntentRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(putIntentRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "PutIntent");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new PutIntentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 Result of the PutSlotType operation returned by the service.
* @throws ConflictException
* There was a conflict processing the request. Try your request again.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @throws 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.
* @sample AmazonLexModelBuilding.PutSlotType
* @see AWS API
* Documentation
*/
@Override
public PutSlotTypeResult putSlotType(PutSlotTypeRequest request) {
request = beforeClientExecution(request);
return executePutSlotType(request);
}
@SdkInternalApi
final PutSlotTypeResult executePutSlotType(PutSlotTypeRequest putSlotTypeRequest) {
ExecutionContext executionContext = createExecutionContext(putSlotTypeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new PutSlotTypeRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(putSlotTypeRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "PutSlotType");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new PutSlotTypeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Starts a job to import a resource to Amazon Lex.
*
*
* @param startImportRequest
* @return Result of the StartImport operation returned by the service.
* @throws LimitExceededException
* The request exceeded a limit. Try your request again.
* @throws InternalFailureException
* An internal Amazon Lex error occurred. Try your request again.
* @throws 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.
* @sample AmazonLexModelBuilding.StartImport
* @see AWS API
* Documentation
*/
@Override
public StartImportResult startImport(StartImportRequest request) {
request = beforeClientExecution(request);
return executeStartImport(request);
}
@SdkInternalApi
final StartImportResult executeStartImport(StartImportRequest startImportRequest) {
ExecutionContext executionContext = createExecutionContext(startImportRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new StartImportRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(startImportRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Lex Model Building Service");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "StartImport");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new StartImportResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* Returns additional metadata for a previously executed successful, request, typically used for debugging issues
* where a service isn't acting as expected. This data isn't considered part of the result data returned by an
* operation, so it's available through this separate, diagnostic interface.
*
* Response metadata is only cached for a limited period of time, so if you need to access this extra diagnostic
* information for an executed request, you should use this method to retrieve it as soon as possible after
* executing the request.
*
* @param request
* The originally executed request
*
* @return The response metadata for the specified request, or null if none is available.
*/
public ResponseMetadata getCachedResponseMetadata(AmazonWebServiceRequest request) {
return client.getResponseMetadataForRequest(request);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
return invoke(request, responseHandler, executionContext, null, null);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI cachedEndpoint, URI uriFromEndpointTrait) {
executionContext.setCredentialsProvider(CredentialUtils.getCredentialsProvider(request.getOriginalRequest(), awsCredentialsProvider));
return doInvoke(request, responseHandler, executionContext, cachedEndpoint, uriFromEndpointTrait);
}
/**
* Invoke with no authentication. Credentials are not required and any credentials set on the client or request will
* be ignored for this operation.
**/
private Response anonymousInvoke(Request request,
HttpResponseHandler> responseHandler, ExecutionContext executionContext) {
return doInvoke(request, responseHandler, executionContext, null, null);
}
/**
* Invoke the request using the http client. Assumes credentials (or lack thereof) have been configured in the
* ExecutionContext beforehand.
**/
private Response doInvoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI discoveredEndpoint, URI uriFromEndpointTrait) {
if (discoveredEndpoint != null) {
request.setEndpoint(discoveredEndpoint);
request.getOriginalRequest().getRequestClientOptions().appendUserAgent("endpoint-discovery");
} else if (uriFromEndpointTrait != null) {
request.setEndpoint(uriFromEndpointTrait);
} else {
request.setEndpoint(endpoint);
}
request.setTimeOffset(timeOffset);
HttpResponseHandler errorResponseHandler = protocolFactory.createErrorResponseHandler(new JsonErrorResponseMetadata());
return client.execute(request, responseHandler, errorResponseHandler, executionContext);
}
@com.amazonaws.annotation.SdkInternalApi
static com.amazonaws.protocol.json.SdkJsonProtocolFactory getProtocolFactory() {
return protocolFactory;
}
}