/*
* Copyright 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.
*/
/*
* Do not modify this file. This file is generated from the lex-models-2017-04-19.normal.json service model.
*/
using System;
using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Net;
using Amazon.LexModelBuildingService.Model;
using Amazon.LexModelBuildingService.Model.Internal.MarshallTransformations;
using Amazon.LexModelBuildingService.Internal;
using Amazon.Runtime;
using Amazon.Runtime.Internal;
using Amazon.Runtime.Internal.Auth;
using Amazon.Runtime.Internal.Transform;
namespace Amazon.LexModelBuildingService
{
///
/// Implementation for accessing LexModelBuildingService
///
/// 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.
///
///
public partial class AmazonLexModelBuildingServiceClient : AmazonServiceClient, IAmazonLexModelBuildingService
{
private static IServiceMetadata serviceMetadata = new AmazonLexModelBuildingServiceMetadata();
#region Constructors
///
/// Constructs AmazonLexModelBuildingServiceClient with the credentials loaded from the application's
/// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance.
///
/// Example App.config with credentials set.
///
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="AWSProfileName" value="AWS Default"/>
/// </appSettings>
/// </configuration>
///
///
///
public AmazonLexModelBuildingServiceClient()
: base(FallbackCredentialsFactory.GetCredentials(), new AmazonLexModelBuildingServiceConfig()) { }
///
/// Constructs AmazonLexModelBuildingServiceClient with the credentials loaded from the application's
/// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance.
///
/// Example App.config with credentials set.
///
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="AWSProfileName" value="AWS Default"/>
/// </appSettings>
/// </configuration>
///
///
///
/// The region to connect.
public AmazonLexModelBuildingServiceClient(RegionEndpoint region)
: base(FallbackCredentialsFactory.GetCredentials(), new AmazonLexModelBuildingServiceConfig{RegionEndpoint = region}) { }
///
/// Constructs AmazonLexModelBuildingServiceClient with the credentials loaded from the application's
/// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance.
///
/// Example App.config with credentials set.
///
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="AWSProfileName" value="AWS Default"/>
/// </appSettings>
/// </configuration>
///
///
///
/// The AmazonLexModelBuildingServiceClient Configuration Object
public AmazonLexModelBuildingServiceClient(AmazonLexModelBuildingServiceConfig config)
: base(FallbackCredentialsFactory.GetCredentials(config), config){}
///
/// Constructs AmazonLexModelBuildingServiceClient with AWS Credentials
///
/// AWS Credentials
public AmazonLexModelBuildingServiceClient(AWSCredentials credentials)
: this(credentials, new AmazonLexModelBuildingServiceConfig())
{
}
///
/// Constructs AmazonLexModelBuildingServiceClient with AWS Credentials
///
/// AWS Credentials
/// The region to connect.
public AmazonLexModelBuildingServiceClient(AWSCredentials credentials, RegionEndpoint region)
: this(credentials, new AmazonLexModelBuildingServiceConfig{RegionEndpoint = region})
{
}
///
/// Constructs AmazonLexModelBuildingServiceClient with AWS Credentials and an
/// AmazonLexModelBuildingServiceClient Configuration object.
///
/// AWS Credentials
/// The AmazonLexModelBuildingServiceClient Configuration Object
public AmazonLexModelBuildingServiceClient(AWSCredentials credentials, AmazonLexModelBuildingServiceConfig clientConfig)
: base(credentials, clientConfig)
{
}
///
/// Constructs AmazonLexModelBuildingServiceClient with AWS Access Key ID and AWS Secret Key
///
/// AWS Access Key ID
/// AWS Secret Access Key
public AmazonLexModelBuildingServiceClient(string awsAccessKeyId, string awsSecretAccessKey)
: this(awsAccessKeyId, awsSecretAccessKey, new AmazonLexModelBuildingServiceConfig())
{
}
///
/// Constructs AmazonLexModelBuildingServiceClient with AWS Access Key ID and AWS Secret Key
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// The region to connect.
public AmazonLexModelBuildingServiceClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region)
: this(awsAccessKeyId, awsSecretAccessKey, new AmazonLexModelBuildingServiceConfig() {RegionEndpoint=region})
{
}
///
/// Constructs AmazonLexModelBuildingServiceClient with AWS Access Key ID, AWS Secret Key and an
/// AmazonLexModelBuildingServiceClient Configuration object.
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// The AmazonLexModelBuildingServiceClient Configuration Object
public AmazonLexModelBuildingServiceClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonLexModelBuildingServiceConfig clientConfig)
: base(awsAccessKeyId, awsSecretAccessKey, clientConfig)
{
}
///
/// Constructs AmazonLexModelBuildingServiceClient with AWS Access Key ID and AWS Secret Key
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// AWS Session Token
public AmazonLexModelBuildingServiceClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken)
: this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonLexModelBuildingServiceConfig())
{
}
///
/// Constructs AmazonLexModelBuildingServiceClient with AWS Access Key ID and AWS Secret Key
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// AWS Session Token
/// The region to connect.
public AmazonLexModelBuildingServiceClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region)
: this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonLexModelBuildingServiceConfig{RegionEndpoint = region})
{
}
///
/// Constructs AmazonLexModelBuildingServiceClient with AWS Access Key ID, AWS Secret Key and an
/// AmazonLexModelBuildingServiceClient Configuration object.
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// AWS Session Token
/// The AmazonLexModelBuildingServiceClient Configuration Object
public AmazonLexModelBuildingServiceClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonLexModelBuildingServiceConfig clientConfig)
: base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig)
{
}
#endregion
#if AWS_ASYNC_ENUMERABLES_API
private ILexModelBuildingServicePaginatorFactory _paginators;
///
/// Paginators for the service
///
public ILexModelBuildingServicePaginatorFactory Paginators
{
get
{
if (this._paginators == null)
{
this._paginators = new LexModelBuildingServicePaginatorFactory(this);
}
return this._paginators;
}
}
#endif
#region Overrides
///
/// Creates the signer for the service.
///
protected override AbstractAWSSigner CreateSigner()
{
return new AWS4Signer();
}
///
/// Customizes the runtime pipeline.
///
/// Runtime pipeline for the current client.
protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline)
{
pipeline.RemoveHandler();
pipeline.AddHandlerAfter(new AmazonLexModelBuildingServiceEndpointResolver());
}
///
/// Capture metadata for the service.
///
protected override IServiceMetadata ServiceMetadata
{
get
{
return serviceMetadata;
}
}
#endregion
#region Dispose
///
/// Disposes the service client.
///
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
}
#endregion
#region CreateBotVersion
internal virtual CreateBotVersionResponse CreateBotVersion(CreateBotVersionRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateBotVersionRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateBotVersionResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
///
/// Container for the necessary parameters to execute the CreateBotVersion service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the CreateBotVersion service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// There was a conflict processing the request. Try your request again.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
///
/// 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.
///
/// REST API Reference for CreateBotVersion Operation
public virtual Task CreateBotVersionAsync(CreateBotVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateBotVersionRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateBotVersionResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region CreateIntentVersion
internal virtual CreateIntentVersionResponse CreateIntentVersion(CreateIntentVersionRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateIntentVersionRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateIntentVersionResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the CreateIntentVersion service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the CreateIntentVersion service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// There was a conflict processing the request. Try your request again.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
///
/// 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.
///
/// REST API Reference for CreateIntentVersion Operation
public virtual Task CreateIntentVersionAsync(CreateIntentVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateIntentVersionRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateIntentVersionResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region CreateSlotTypeVersion
internal virtual CreateSlotTypeVersionResponse CreateSlotTypeVersion(CreateSlotTypeVersionRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateSlotTypeVersionRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateSlotTypeVersionResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the CreateSlotTypeVersion service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the CreateSlotTypeVersion service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// There was a conflict processing the request. Try your request again.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
///
/// 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.
///
/// REST API Reference for CreateSlotTypeVersion Operation
public virtual Task CreateSlotTypeVersionAsync(CreateSlotTypeVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateSlotTypeVersionRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateSlotTypeVersionResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteBot
internal virtual DeleteBotResponse DeleteBot(DeleteBotRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteBotRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteBotResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the DeleteBot service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteBot service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// There was a conflict processing the request. Try your request again.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
///
/// 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 } }
///
///
/// REST API Reference for DeleteBot Operation
public virtual Task DeleteBotAsync(DeleteBotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteBotRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteBotResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteBotAlias
internal virtual DeleteBotAliasResponse DeleteBotAlias(DeleteBotAliasRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteBotAliasRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteBotAliasResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the DeleteBotAlias service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteBotAlias service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// There was a conflict processing the request. Try your request again.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
///
/// 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 } }
///
///
/// REST API Reference for DeleteBotAlias Operation
public virtual Task DeleteBotAliasAsync(DeleteBotAliasRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteBotAliasRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteBotAliasResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteBotChannelAssociation
internal virtual DeleteBotChannelAssociationResponse DeleteBotChannelAssociation(DeleteBotChannelAssociationRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteBotChannelAssociationRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteBotChannelAssociationResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Deletes the association between an Amazon Lex bot and a messaging platform.
///
///
///
/// This operation requires permission for the lex:DeleteBotChannelAssociation
/// action.
///
///
/// Container for the necessary parameters to execute the DeleteBotChannelAssociation service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteBotChannelAssociation service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// There was a conflict processing the request. Try your request again.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for DeleteBotChannelAssociation Operation
public virtual Task DeleteBotChannelAssociationAsync(DeleteBotChannelAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteBotChannelAssociationRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteBotChannelAssociationResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteBotVersion
internal virtual DeleteBotVersionResponse DeleteBotVersion(DeleteBotVersionRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteBotVersionRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteBotVersionResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the DeleteBotVersion service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteBotVersion service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// There was a conflict processing the request. Try your request again.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
///
/// 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 } }
///
///
/// REST API Reference for DeleteBotVersion Operation
public virtual Task DeleteBotVersionAsync(DeleteBotVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteBotVersionRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteBotVersionResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteIntent
internal virtual DeleteIntentResponse DeleteIntent(DeleteIntentRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteIntentRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteIntentResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
///
/// Container for the necessary parameters to execute the DeleteIntent service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteIntent service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// There was a conflict processing the request. Try your request again.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
///
/// 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 } }
///
///
/// REST API Reference for DeleteIntent Operation
public virtual Task DeleteIntentAsync(DeleteIntentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteIntentRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteIntentResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteIntentVersion
internal virtual DeleteIntentVersionResponse DeleteIntentVersion(DeleteIntentVersionRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteIntentVersionRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteIntentVersionResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the DeleteIntentVersion service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteIntentVersion service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// There was a conflict processing the request. Try your request again.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
///
/// 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 } }
///
///
/// REST API Reference for DeleteIntentVersion Operation
public virtual Task DeleteIntentVersionAsync(DeleteIntentVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteIntentVersionRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteIntentVersionResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteSlotType
internal virtual DeleteSlotTypeResponse DeleteSlotType(DeleteSlotTypeRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteSlotTypeRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteSlotTypeResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the DeleteSlotType service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteSlotType service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// There was a conflict processing the request. Try your request again.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
///
/// 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 } }
///
///
/// REST API Reference for DeleteSlotType Operation
public virtual Task DeleteSlotTypeAsync(DeleteSlotTypeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteSlotTypeRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteSlotTypeResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteSlotTypeVersion
internal virtual DeleteSlotTypeVersionResponse DeleteSlotTypeVersion(DeleteSlotTypeVersionRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteSlotTypeVersionRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteSlotTypeVersionResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the DeleteSlotTypeVersion service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteSlotTypeVersion service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// There was a conflict processing the request. Try your request again.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
///
/// 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 } }
///
///
/// REST API Reference for DeleteSlotTypeVersion Operation
public virtual Task DeleteSlotTypeVersionAsync(DeleteSlotTypeVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteSlotTypeVersionRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteSlotTypeVersionResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteUtterances
internal virtual DeleteUtterancesResponse DeleteUtterances(DeleteUtterancesRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteUtterancesRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteUtterancesResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the DeleteUtterances service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteUtterances service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for DeleteUtterances Operation
public virtual Task DeleteUtterancesAsync(DeleteUtterancesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteUtterancesRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteUtterancesResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetBot
internal virtual GetBotResponse GetBot(GetBotRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetBotRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetBotResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the GetBot service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetBot service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for GetBot Operation
public virtual Task GetBotAsync(GetBotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetBotRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetBotResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetBotAlias
internal virtual GetBotAliasResponse GetBotAlias(GetBotAliasRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetBotAliasRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetBotAliasResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the GetBotAlias service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetBotAlias service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for GetBotAlias Operation
public virtual Task GetBotAliasAsync(GetBotAliasRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetBotAliasRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetBotAliasResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetBotAliases
internal virtual GetBotAliasesResponse GetBotAliases(GetBotAliasesRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetBotAliasesRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetBotAliasesResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns a list of aliases for a specified Amazon Lex bot.
///
///
///
/// This operation requires permissions for the lex:GetBotAliases action.
///
///
/// Container for the necessary parameters to execute the GetBotAliases service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetBotAliases service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
/// REST API Reference for GetBotAliases Operation
public virtual Task GetBotAliasesAsync(GetBotAliasesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetBotAliasesRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetBotAliasesResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetBotChannelAssociation
internal virtual GetBotChannelAssociationResponse GetBotChannelAssociation(GetBotChannelAssociationRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetBotChannelAssociationRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetBotChannelAssociationResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns information about the association between an Amazon Lex bot and a messaging
/// platform.
///
///
///
/// This operation requires permissions for the lex:GetBotChannelAssociation
/// action.
///
///
/// Container for the necessary parameters to execute the GetBotChannelAssociation service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetBotChannelAssociation service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for GetBotChannelAssociation Operation
public virtual Task GetBotChannelAssociationAsync(GetBotChannelAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetBotChannelAssociationRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetBotChannelAssociationResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetBotChannelAssociations
internal virtual GetBotChannelAssociationsResponse GetBotChannelAssociations(GetBotChannelAssociationsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetBotChannelAssociationsRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetBotChannelAssociationsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns a list of all of the channels associated with the specified bot.
///
///
///
/// The GetBotChannelAssociations operation requires permissions for the
/// lex:GetBotChannelAssociations action.
///
///
/// Container for the necessary parameters to execute the GetBotChannelAssociations service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetBotChannelAssociations service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
/// REST API Reference for GetBotChannelAssociations Operation
public virtual Task GetBotChannelAssociationsAsync(GetBotChannelAssociationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetBotChannelAssociationsRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetBotChannelAssociationsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetBots
internal virtual GetBotsResponse GetBots(GetBotsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetBotsRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetBotsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the GetBots service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetBots service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for GetBots Operation
public virtual Task GetBotsAsync(GetBotsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetBotsRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetBotsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetBotVersions
internal virtual GetBotVersionsResponse GetBotVersions(GetBotVersionsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetBotVersionsRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetBotVersionsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the GetBotVersions service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetBotVersions service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for GetBotVersions Operation
public virtual Task GetBotVersionsAsync(GetBotVersionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetBotVersionsRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetBotVersionsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetBuiltinIntent
internal virtual GetBuiltinIntentResponse GetBuiltinIntent(GetBuiltinIntentRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetBuiltinIntentRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetBuiltinIntentResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns information about a built-in intent.
///
///
///
/// This operation requires permission for the lex:GetBuiltinIntent action.
///
///
/// Container for the necessary parameters to execute the GetBuiltinIntent service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetBuiltinIntent service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for GetBuiltinIntent Operation
public virtual Task GetBuiltinIntentAsync(GetBuiltinIntentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetBuiltinIntentRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetBuiltinIntentResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetBuiltinIntents
internal virtual GetBuiltinIntentsResponse GetBuiltinIntents(GetBuiltinIntentsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetBuiltinIntentsRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetBuiltinIntentsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Gets a list of built-in intents that meet the specified criteria.
///
///
///
/// This operation requires permission for the lex:GetBuiltinIntents action.
///
///
/// Container for the necessary parameters to execute the GetBuiltinIntents service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetBuiltinIntents service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
/// REST API Reference for GetBuiltinIntents Operation
public virtual Task GetBuiltinIntentsAsync(GetBuiltinIntentsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetBuiltinIntentsRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetBuiltinIntentsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetBuiltinSlotTypes
internal virtual GetBuiltinSlotTypesResponse GetBuiltinSlotTypes(GetBuiltinSlotTypesRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetBuiltinSlotTypesRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetBuiltinSlotTypesResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the GetBuiltinSlotTypes service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetBuiltinSlotTypes service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
/// REST API Reference for GetBuiltinSlotTypes Operation
public virtual Task GetBuiltinSlotTypesAsync(GetBuiltinSlotTypesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetBuiltinSlotTypesRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetBuiltinSlotTypesResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetExport
internal virtual GetExportResponse GetExport(GetExportRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetExportRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetExportResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Exports the contents of a Amazon Lex resource in a specified format.
///
/// Container for the necessary parameters to execute the GetExport service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetExport service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for GetExport Operation
public virtual Task GetExportAsync(GetExportRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetExportRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetExportResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetImport
internal virtual GetImportResponse GetImport(GetImportRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetImportRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetImportResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Gets information about an import job started with the StartImport operation.
///
/// Container for the necessary parameters to execute the GetImport service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetImport service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for GetImport Operation
public virtual Task GetImportAsync(GetImportRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetImportRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetImportResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetIntent
internal virtual GetIntentResponse GetIntent(GetIntentRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetIntentRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetIntentResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
///
/// Container for the necessary parameters to execute the GetIntent service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetIntent service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for GetIntent Operation
public virtual Task GetIntentAsync(GetIntentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetIntentRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetIntentResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetIntents
internal virtual GetIntentsResponse GetIntents(GetIntentsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetIntentsRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetIntentsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the GetIntents service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetIntents service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for GetIntents Operation
public virtual Task GetIntentsAsync(GetIntentsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetIntentsRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetIntentsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetIntentVersions
internal virtual GetIntentVersionsResponse GetIntentVersions(GetIntentVersionsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetIntentVersionsRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetIntentVersionsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the GetIntentVersions service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetIntentVersions service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for GetIntentVersions Operation
public virtual Task GetIntentVersionsAsync(GetIntentVersionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetIntentVersionsRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetIntentVersionsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetMigration
internal virtual GetMigrationResponse GetMigration(GetMigrationRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetMigrationRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetMigrationResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Provides details about an ongoing or complete migration from an Amazon Lex V1 bot
/// to an Amazon Lex V2 bot. Use this operation to view the migration alerts and warnings
/// related to the migration.
///
/// Container for the necessary parameters to execute the GetMigration service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetMigration service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for GetMigration Operation
public virtual Task GetMigrationAsync(GetMigrationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetMigrationRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetMigrationResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetMigrations
internal virtual GetMigrationsResponse GetMigrations(GetMigrationsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetMigrationsRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetMigrationsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Gets a list of migrations between Amazon Lex V1 and Amazon Lex V2.
///
/// Container for the necessary parameters to execute the GetMigrations service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetMigrations service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
/// REST API Reference for GetMigrations Operation
public virtual Task GetMigrationsAsync(GetMigrationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetMigrationsRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetMigrationsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetSlotType
internal virtual GetSlotTypeResponse GetSlotType(GetSlotTypeRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetSlotTypeRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetSlotTypeResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the GetSlotType service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetSlotType service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for GetSlotType Operation
public virtual Task GetSlotTypeAsync(GetSlotTypeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetSlotTypeRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetSlotTypeResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetSlotTypes
internal virtual GetSlotTypesResponse GetSlotTypes(GetSlotTypesRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetSlotTypesRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetSlotTypesResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the GetSlotTypes service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetSlotTypes service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for GetSlotTypes Operation
public virtual Task GetSlotTypesAsync(GetSlotTypesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetSlotTypesRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetSlotTypesResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetSlotTypeVersions
internal virtual GetSlotTypeVersionsResponse GetSlotTypeVersions(GetSlotTypeVersionsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetSlotTypeVersionsRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetSlotTypeVersionsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the GetSlotTypeVersions service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetSlotTypeVersions service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for GetSlotTypeVersions Operation
public virtual Task GetSlotTypeVersionsAsync(GetSlotTypeVersionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetSlotTypeVersionsRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetSlotTypeVersionsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetUtterancesView
internal virtual GetUtterancesViewResponse GetUtterancesView(GetUtterancesViewRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetUtterancesViewRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetUtterancesViewResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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, if
/// you are using slot obfuscation with one or more slots, or if you opted out of participating
/// in improving Amazon Lex, utterances are not available.
///
///
///
/// This operation requires permissions for the lex:GetUtterancesView action.
///
///
/// Container for the necessary parameters to execute the GetUtterancesView service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetUtterancesView service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
/// REST API Reference for GetUtterancesView Operation
public virtual Task GetUtterancesViewAsync(GetUtterancesViewRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetUtterancesViewRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetUtterancesViewResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region ListTagsForResource
internal virtual ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Gets a list of tags associated with the specified resource. Only bots, bot aliases,
/// and bot channels can have tags associated with them.
///
/// Container for the necessary parameters to execute the ListTagsForResource service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the ListTagsForResource service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for ListTagsForResource Operation
public virtual Task ListTagsForResourceAsync(ListTagsForResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region PutBot
internal virtual PutBotResponse PutBot(PutBotRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = PutBotRequestMarshaller.Instance;
options.ResponseUnmarshaller = PutBotResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the PutBot service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the PutBot service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// There was a conflict processing the request. Try your request again.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// 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.
///
/// REST API Reference for PutBot Operation
public virtual Task PutBotAsync(PutBotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = PutBotRequestMarshaller.Instance;
options.ResponseUnmarshaller = PutBotResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region PutBotAlias
internal virtual PutBotAliasResponse PutBotAlias(PutBotAliasRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = PutBotAliasRequestMarshaller.Instance;
options.ResponseUnmarshaller = PutBotAliasResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the PutBotAlias service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the PutBotAlias service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// There was a conflict processing the request. Try your request again.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// 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.
///
/// REST API Reference for PutBotAlias Operation
public virtual Task PutBotAliasAsync(PutBotAliasRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = PutBotAliasRequestMarshaller.Instance;
options.ResponseUnmarshaller = PutBotAliasResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region PutIntent
internal virtual PutIntentResponse PutIntent(PutIntentRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = PutIntentRequestMarshaller.Instance;
options.ResponseUnmarshaller = PutIntentResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the PutIntent service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the PutIntent service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// There was a conflict processing the request. Try your request again.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// 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.
///
/// REST API Reference for PutIntent Operation
public virtual Task PutIntentAsync(PutIntentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = PutIntentRequestMarshaller.Instance;
options.ResponseUnmarshaller = PutIntentResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region PutSlotType
internal virtual PutSlotTypeResponse PutSlotType(PutSlotTypeRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = PutSlotTypeRequestMarshaller.Instance;
options.ResponseUnmarshaller = PutSlotTypeResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the PutSlotType service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the PutSlotType service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// There was a conflict processing the request. Try your request again.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// 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.
///
/// REST API Reference for PutSlotType Operation
public virtual Task PutSlotTypeAsync(PutSlotTypeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = PutSlotTypeRequestMarshaller.Instance;
options.ResponseUnmarshaller = PutSlotTypeResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region StartImport
internal virtual StartImportResponse StartImport(StartImportRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = StartImportRequestMarshaller.Instance;
options.ResponseUnmarshaller = StartImportResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Starts a job to import a resource to Amazon Lex.
///
/// Container for the necessary parameters to execute the StartImport service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the StartImport service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
/// REST API Reference for StartImport Operation
public virtual Task StartImportAsync(StartImportRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = StartImportRequestMarshaller.Instance;
options.ResponseUnmarshaller = StartImportResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region StartMigration
internal virtual StartMigrationResponse StartMigration(StartMigrationRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = StartMigrationRequestMarshaller.Instance;
options.ResponseUnmarshaller = StartMigrationResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Starts migrating a bot from Amazon Lex V1 to Amazon Lex V2. Migrate your bot when
/// you want to take advantage of the new features of Amazon Lex V2.
///
///
///
/// For more information, see Migrating
/// a bot in the Amazon Lex developer guide.
///
///
/// Container for the necessary parameters to execute the StartMigration service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the StartMigration service method, as returned by LexModelBuildingService.
///
/// Your IAM user or role does not have permission to call the Amazon Lex V2 APIs required
/// to migrate your bot.
///
///
/// 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.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for StartMigration Operation
public virtual Task StartMigrationAsync(StartMigrationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = StartMigrationRequestMarshaller.Instance;
options.ResponseUnmarshaller = StartMigrationResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region TagResource
internal virtual TagResourceResponse TagResource(TagResourceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = TagResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Adds the specified tags to the specified resource. If a tag key already exists, the
/// existing value is replaced with the new value.
///
/// Container for the necessary parameters to execute the TagResource service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the TagResource service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// There was a conflict processing the request. Try your request again.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for TagResource Operation
public virtual Task TagResourceAsync(TagResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = TagResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region UntagResource
internal virtual UntagResourceResponse UntagResource(UntagResourceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UntagResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Removes tags from a bot, bot alias or bot channel.
///
/// Container for the necessary parameters to execute the UntagResource service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the UntagResource service method, as returned by LexModelBuildingService.
///
/// 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.
///
///
/// There was a conflict processing the request. Try your request again.
///
///
/// An internal Amazon Lex error occurred. Try your request again.
///
///
/// The request exceeded a limit. Try your request again.
///
///
/// The resource specified in the request was not found. Check the resource and try again.
///
/// REST API Reference for UntagResource Operation
public virtual Task UntagResourceAsync(UntagResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = UntagResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
}
}