/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace LexModelsV2 { /** *

*/ class AWS_LEXMODELSV2_API LexModelsV2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef LexModelsV2ClientConfiguration ClientConfigurationType; typedef LexModelsV2EndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ LexModelsV2Client(const Aws::LexModelsV2::LexModelsV2ClientConfiguration& clientConfiguration = Aws::LexModelsV2::LexModelsV2ClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ LexModelsV2Client(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::LexModelsV2::LexModelsV2ClientConfiguration& clientConfiguration = Aws::LexModelsV2::LexModelsV2ClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ LexModelsV2Client(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::LexModelsV2::LexModelsV2ClientConfiguration& clientConfiguration = Aws::LexModelsV2::LexModelsV2ClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ LexModelsV2Client(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ LexModelsV2Client(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ LexModelsV2Client(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~LexModelsV2Client(); /** *

Create a batch of custom vocabulary items for a given bot locale's custom * vocabulary.

See Also:

AWS * API Reference

*/ virtual Model::BatchCreateCustomVocabularyItemOutcome BatchCreateCustomVocabularyItem(const Model::BatchCreateCustomVocabularyItemRequest& request) const; /** * A Callable wrapper for BatchCreateCustomVocabularyItem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchCreateCustomVocabularyItemOutcomeCallable BatchCreateCustomVocabularyItemCallable(const BatchCreateCustomVocabularyItemRequestT& request) const { return SubmitCallable(&LexModelsV2Client::BatchCreateCustomVocabularyItem, request); } /** * An Async wrapper for BatchCreateCustomVocabularyItem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchCreateCustomVocabularyItemAsync(const BatchCreateCustomVocabularyItemRequestT& request, const BatchCreateCustomVocabularyItemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::BatchCreateCustomVocabularyItem, request, handler, context); } /** *

Delete a batch of custom vocabulary items for a given bot locale's custom * vocabulary.

See Also:

AWS * API Reference

*/ virtual Model::BatchDeleteCustomVocabularyItemOutcome BatchDeleteCustomVocabularyItem(const Model::BatchDeleteCustomVocabularyItemRequest& request) const; /** * A Callable wrapper for BatchDeleteCustomVocabularyItem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchDeleteCustomVocabularyItemOutcomeCallable BatchDeleteCustomVocabularyItemCallable(const BatchDeleteCustomVocabularyItemRequestT& request) const { return SubmitCallable(&LexModelsV2Client::BatchDeleteCustomVocabularyItem, request); } /** * An Async wrapper for BatchDeleteCustomVocabularyItem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchDeleteCustomVocabularyItemAsync(const BatchDeleteCustomVocabularyItemRequestT& request, const BatchDeleteCustomVocabularyItemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::BatchDeleteCustomVocabularyItem, request, handler, context); } /** *

Update a batch of custom vocabulary items for a given bot locale's custom * vocabulary.

See Also:

AWS * API Reference

*/ virtual Model::BatchUpdateCustomVocabularyItemOutcome BatchUpdateCustomVocabularyItem(const Model::BatchUpdateCustomVocabularyItemRequest& request) const; /** * A Callable wrapper for BatchUpdateCustomVocabularyItem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchUpdateCustomVocabularyItemOutcomeCallable BatchUpdateCustomVocabularyItemCallable(const BatchUpdateCustomVocabularyItemRequestT& request) const { return SubmitCallable(&LexModelsV2Client::BatchUpdateCustomVocabularyItem, request); } /** * An Async wrapper for BatchUpdateCustomVocabularyItem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchUpdateCustomVocabularyItemAsync(const BatchUpdateCustomVocabularyItemRequestT& request, const BatchUpdateCustomVocabularyItemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::BatchUpdateCustomVocabularyItem, request, handler, context); } /** *

Builds a bot, its intents, and its slot types into a specific locale. A bot * can be built into multiple locales. At runtime the locale is used to choose a * specific build of the bot.

See Also:

AWS * API Reference

*/ virtual Model::BuildBotLocaleOutcome BuildBotLocale(const Model::BuildBotLocaleRequest& request) const; /** * A Callable wrapper for BuildBotLocale that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BuildBotLocaleOutcomeCallable BuildBotLocaleCallable(const BuildBotLocaleRequestT& request) const { return SubmitCallable(&LexModelsV2Client::BuildBotLocale, request); } /** * An Async wrapper for BuildBotLocale that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BuildBotLocaleAsync(const BuildBotLocaleRequestT& request, const BuildBotLocaleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::BuildBotLocale, request, handler, context); } /** *

Creates an Amazon Lex conversational bot.

See Also:

AWS * API Reference

*/ virtual Model::CreateBotOutcome CreateBot(const Model::CreateBotRequest& request) const; /** * A Callable wrapper for CreateBot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateBotOutcomeCallable CreateBotCallable(const CreateBotRequestT& request) const { return SubmitCallable(&LexModelsV2Client::CreateBot, request); } /** * An Async wrapper for CreateBot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateBotAsync(const CreateBotRequestT& request, const CreateBotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::CreateBot, request, handler, context); } /** *

Creates an alias for the specified version of a bot. Use an alias to enable * you to change the version of a bot without updating applications that use the * bot.

For example, you can create an alias called "PROD" that your * applications use to call the Amazon Lex bot.

See Also:

AWS * API Reference

*/ virtual Model::CreateBotAliasOutcome CreateBotAlias(const Model::CreateBotAliasRequest& request) const; /** * A Callable wrapper for CreateBotAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateBotAliasOutcomeCallable CreateBotAliasCallable(const CreateBotAliasRequestT& request) const { return SubmitCallable(&LexModelsV2Client::CreateBotAlias, request); } /** * An Async wrapper for CreateBotAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateBotAliasAsync(const CreateBotAliasRequestT& request, const CreateBotAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::CreateBotAlias, request, handler, context); } /** *

Creates a locale in the bot. The locale contains the intents and slot types * that the bot uses in conversations with users in the specified language and * locale. You must add a locale to a bot before you can add intents and slot types * to the bot.

See Also:

AWS * API Reference

*/ virtual Model::CreateBotLocaleOutcome CreateBotLocale(const Model::CreateBotLocaleRequest& request) const; /** * A Callable wrapper for CreateBotLocale that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateBotLocaleOutcomeCallable CreateBotLocaleCallable(const CreateBotLocaleRequestT& request) const { return SubmitCallable(&LexModelsV2Client::CreateBotLocale, request); } /** * An Async wrapper for CreateBotLocale that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateBotLocaleAsync(const CreateBotLocaleRequestT& request, const CreateBotLocaleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::CreateBotLocale, request, handler, context); } /** *

Creates a new version of the bot based on the DRAFT version. If * the DRAFT 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.

When you create the first version of a bot, Amazon Lex * sets the version to 1. Subsequent versions increment by 1.

See * Also:

AWS * API Reference

*/ virtual Model::CreateBotVersionOutcome CreateBotVersion(const Model::CreateBotVersionRequest& request) const; /** * A Callable wrapper for CreateBotVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateBotVersionOutcomeCallable CreateBotVersionCallable(const CreateBotVersionRequestT& request) const { return SubmitCallable(&LexModelsV2Client::CreateBotVersion, request); } /** * An Async wrapper for CreateBotVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateBotVersionAsync(const CreateBotVersionRequestT& request, const CreateBotVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::CreateBotVersion, request, handler, context); } /** *

Creates a zip archive containing the contents of a bot or a bot locale. The * archive contains a directory structure that contains JSON files that define the * bot.

You can create an archive that contains the complete definition of a * bot, or you can specify that the archive contain only the definition of a single * bot locale.

For more information about exporting bots, and about the * structure of the export archive, see * Importing and exporting bots

See Also:

AWS * API Reference

*/ virtual Model::CreateExportOutcome CreateExport(const Model::CreateExportRequest& request) const; /** * A Callable wrapper for CreateExport that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateExportOutcomeCallable CreateExportCallable(const CreateExportRequestT& request) const { return SubmitCallable(&LexModelsV2Client::CreateExport, request); } /** * An Async wrapper for CreateExport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateExportAsync(const CreateExportRequestT& request, const CreateExportResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::CreateExport, request, handler, context); } /** *

Creates an intent.

To define the interaction between the user and your * bot, you define one or more intents. For example, for a pizza ordering bot you * would create an OrderPizza intent.

When you create an * intent, you must provide a name. You can optionally provide the following:

*

  • Sample utterances. For example, "I want to order a pizza" and "Can * I order a pizza." You can't provide utterances for built-in intents.

    • *

  • Information to be gathered. You specify slots for the information that * you bot requests from the user. You can specify standard slot types, such as * date and time, or custom slot types for your application.

  • How * the intent is fulfilled. You can provide a Lambda function or configure the * intent to return the intent information to your client application. If you use a * Lambda function, Amazon Lex invokes the function when all of the intent * information is available.

  • A confirmation prompt to send to the * user to confirm an intent. For example, "Shall I order your pizza?"

    • *

  • A conclusion statement to send to the user after the intent is * fulfilled. For example, "I ordered your pizza."

  • A follow-up * prompt that asks the user for additional activity. For example, "Do you want a * drink with your pizza?"

See Also:

AWS * API Reference

*/ virtual Model::CreateIntentOutcome CreateIntent(const Model::CreateIntentRequest& request) const; /** * A Callable wrapper for CreateIntent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateIntentOutcomeCallable CreateIntentCallable(const CreateIntentRequestT& request) const { return SubmitCallable(&LexModelsV2Client::CreateIntent, request); } /** * An Async wrapper for CreateIntent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateIntentAsync(const CreateIntentRequestT& request, const CreateIntentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::CreateIntent, request, handler, context); } /** *

Creates a new resource policy with the specified policy * statements.

See Also:

AWS * API Reference

*/ virtual Model::CreateResourcePolicyOutcome CreateResourcePolicy(const Model::CreateResourcePolicyRequest& request) const; /** * A Callable wrapper for CreateResourcePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateResourcePolicyOutcomeCallable CreateResourcePolicyCallable(const CreateResourcePolicyRequestT& request) const { return SubmitCallable(&LexModelsV2Client::CreateResourcePolicy, request); } /** * An Async wrapper for CreateResourcePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateResourcePolicyAsync(const CreateResourcePolicyRequestT& request, const CreateResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::CreateResourcePolicy, request, handler, context); } /** *

Adds a new resource policy statement to a bot or bot alias. If a resource * policy exists, the statement is added to the current resource policy. If a * policy doesn't exist, a new policy is created.

You can't create a * resource policy statement that allows cross-account access.

See * Also:

AWS * API Reference

*/ virtual Model::CreateResourcePolicyStatementOutcome CreateResourcePolicyStatement(const Model::CreateResourcePolicyStatementRequest& request) const; /** * A Callable wrapper for CreateResourcePolicyStatement that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateResourcePolicyStatementOutcomeCallable CreateResourcePolicyStatementCallable(const CreateResourcePolicyStatementRequestT& request) const { return SubmitCallable(&LexModelsV2Client::CreateResourcePolicyStatement, request); } /** * An Async wrapper for CreateResourcePolicyStatement that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateResourcePolicyStatementAsync(const CreateResourcePolicyStatementRequestT& request, const CreateResourcePolicyStatementResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::CreateResourcePolicyStatement, request, handler, context); } /** *

Creates a slot in an intent. A slot is a variable needed to fulfill an * intent. For example, an OrderPizza intent might need slots for * size, crust, and number of pizzas. For each slot, you define one or more * utterances that Amazon Lex uses to elicit a response from the user. *

See Also:

AWS * API Reference

*/ virtual Model::CreateSlotOutcome CreateSlot(const Model::CreateSlotRequest& request) const; /** * A Callable wrapper for CreateSlot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSlotOutcomeCallable CreateSlotCallable(const CreateSlotRequestT& request) const { return SubmitCallable(&LexModelsV2Client::CreateSlot, request); } /** * An Async wrapper for CreateSlot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSlotAsync(const CreateSlotRequestT& request, const CreateSlotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::CreateSlot, request, handler, context); } /** *

Creates a custom slot type

To create a custom slot type, specify a * name for the slot type and a set of enumeration values, the values that a slot * of this type can assume.

See Also:

AWS * API Reference

*/ virtual Model::CreateSlotTypeOutcome CreateSlotType(const Model::CreateSlotTypeRequest& request) const; /** * A Callable wrapper for CreateSlotType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSlotTypeOutcomeCallable CreateSlotTypeCallable(const CreateSlotTypeRequestT& request) const { return SubmitCallable(&LexModelsV2Client::CreateSlotType, request); } /** * An Async wrapper for CreateSlotType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSlotTypeAsync(const CreateSlotTypeRequestT& request, const CreateSlotTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::CreateSlotType, request, handler, context); } /** *

Create a report that describes the differences between the bot and the test * set.

See Also:

AWS * API Reference

*/ virtual Model::CreateTestSetDiscrepancyReportOutcome CreateTestSetDiscrepancyReport(const Model::CreateTestSetDiscrepancyReportRequest& request) const; /** * A Callable wrapper for CreateTestSetDiscrepancyReport that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTestSetDiscrepancyReportOutcomeCallable CreateTestSetDiscrepancyReportCallable(const CreateTestSetDiscrepancyReportRequestT& request) const { return SubmitCallable(&LexModelsV2Client::CreateTestSetDiscrepancyReport, request); } /** * An Async wrapper for CreateTestSetDiscrepancyReport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTestSetDiscrepancyReportAsync(const CreateTestSetDiscrepancyReportRequestT& request, const CreateTestSetDiscrepancyReportResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::CreateTestSetDiscrepancyReport, request, handler, context); } /** *

Gets a pre-signed S3 write URL that you use to upload the zip archive when * importing a bot or a bot locale.

See Also:

AWS * API Reference

*/ virtual Model::CreateUploadUrlOutcome CreateUploadUrl(const Model::CreateUploadUrlRequest& request) const; /** * A Callable wrapper for CreateUploadUrl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateUploadUrlOutcomeCallable CreateUploadUrlCallable(const CreateUploadUrlRequestT& request) const { return SubmitCallable(&LexModelsV2Client::CreateUploadUrl, request); } /** * An Async wrapper for CreateUploadUrl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateUploadUrlAsync(const CreateUploadUrlRequestT& request, const CreateUploadUrlResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::CreateUploadUrl, request, handler, context); } /** *

Deletes all versions of a bot, including the Draft version. To * delete a specific version, use the DeleteBotVersion operation.

*

When you delete a bot, all of the resources contained in the bot are also * deleted. Deleting a bot removes all locales, intents, slot, and slot types * defined for the bot.

If a bot has an alias, the DeleteBot * operation returns a ResourceInUseException exception. If you want * to delete the bot and the alias, set the skipResourceInUseCheck * parameter to true.

See Also:

AWS * API Reference

*/ virtual Model::DeleteBotOutcome DeleteBot(const Model::DeleteBotRequest& request) const; /** * A Callable wrapper for DeleteBot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBotOutcomeCallable DeleteBotCallable(const DeleteBotRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DeleteBot, request); } /** * An Async wrapper for DeleteBot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBotAsync(const DeleteBotRequestT& request, const DeleteBotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DeleteBot, request, handler, context); } /** *

Deletes the specified bot alias.

See Also:

AWS * API Reference

*/ virtual Model::DeleteBotAliasOutcome DeleteBotAlias(const Model::DeleteBotAliasRequest& request) const; /** * A Callable wrapper for DeleteBotAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBotAliasOutcomeCallable DeleteBotAliasCallable(const DeleteBotAliasRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DeleteBotAlias, request); } /** * An Async wrapper for DeleteBotAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBotAliasAsync(const DeleteBotAliasRequestT& request, const DeleteBotAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DeleteBotAlias, request, handler, context); } /** *

Removes a locale from a bot.

When you delete a locale, all intents, * slots, and slot types defined for the locale are also deleted.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteBotLocaleOutcome DeleteBotLocale(const Model::DeleteBotLocaleRequest& request) const; /** * A Callable wrapper for DeleteBotLocale that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBotLocaleOutcomeCallable DeleteBotLocaleCallable(const DeleteBotLocaleRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DeleteBotLocale, request); } /** * An Async wrapper for DeleteBotLocale that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBotLocaleAsync(const DeleteBotLocaleRequestT& request, const DeleteBotLocaleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DeleteBotLocale, request, handler, context); } /** *

Deletes a specific version of a bot. To delete all versions of a bot, use the * DeleteBot * operation.

See Also:

AWS * API Reference

*/ virtual Model::DeleteBotVersionOutcome DeleteBotVersion(const Model::DeleteBotVersionRequest& request) const; /** * A Callable wrapper for DeleteBotVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBotVersionOutcomeCallable DeleteBotVersionCallable(const DeleteBotVersionRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DeleteBotVersion, request); } /** * An Async wrapper for DeleteBotVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBotVersionAsync(const DeleteBotVersionRequestT& request, const DeleteBotVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DeleteBotVersion, request, handler, context); } /** *

Removes a custom vocabulary from the specified locale in the specified * bot.

See Also:

AWS * API Reference

*/ virtual Model::DeleteCustomVocabularyOutcome DeleteCustomVocabulary(const Model::DeleteCustomVocabularyRequest& request) const; /** * A Callable wrapper for DeleteCustomVocabulary that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCustomVocabularyOutcomeCallable DeleteCustomVocabularyCallable(const DeleteCustomVocabularyRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DeleteCustomVocabulary, request); } /** * An Async wrapper for DeleteCustomVocabulary that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCustomVocabularyAsync(const DeleteCustomVocabularyRequestT& request, const DeleteCustomVocabularyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DeleteCustomVocabulary, request, handler, context); } /** *

Removes a previous export and the associated files stored in an S3 * bucket.

See Also:

AWS * API Reference

*/ virtual Model::DeleteExportOutcome DeleteExport(const Model::DeleteExportRequest& request) const; /** * A Callable wrapper for DeleteExport that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteExportOutcomeCallable DeleteExportCallable(const DeleteExportRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DeleteExport, request); } /** * An Async wrapper for DeleteExport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteExportAsync(const DeleteExportRequestT& request, const DeleteExportResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DeleteExport, request, handler, context); } /** *

Removes a previous import and the associated file stored in an S3 * bucket.

See Also:

AWS * API Reference

*/ virtual Model::DeleteImportOutcome DeleteImport(const Model::DeleteImportRequest& request) const; /** * A Callable wrapper for DeleteImport that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteImportOutcomeCallable DeleteImportCallable(const DeleteImportRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DeleteImport, request); } /** * An Async wrapper for DeleteImport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteImportAsync(const DeleteImportRequestT& request, const DeleteImportResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DeleteImport, request, handler, context); } /** *

Removes the specified intent.

Deleting an intent also deletes the * slots associated with the intent.

See Also:

AWS * API Reference

*/ virtual Model::DeleteIntentOutcome DeleteIntent(const Model::DeleteIntentRequest& request) const; /** * A Callable wrapper for DeleteIntent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteIntentOutcomeCallable DeleteIntentCallable(const DeleteIntentRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DeleteIntent, request); } /** * An Async wrapper for DeleteIntent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteIntentAsync(const DeleteIntentRequestT& request, const DeleteIntentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DeleteIntent, request, handler, context); } /** *

Removes an existing policy from a bot or bot alias. If the resource doesn't * have a policy attached, Amazon Lex returns an exception.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request) const; /** * A Callable wrapper for DeleteResourcePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DeleteResourcePolicy, request); } /** * An Async wrapper for DeleteResourcePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteResourcePolicyAsync(const DeleteResourcePolicyRequestT& request, const DeleteResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DeleteResourcePolicy, request, handler, context); } /** *

Deletes a policy statement from a resource policy. If you delete the last * statement from a policy, the policy is deleted. If you specify a statement ID * that doesn't exist in the policy, or if the bot or bot alias doesn't have a * policy attached, Amazon Lex returns an exception.

See Also:

AWS * API Reference

*/ virtual Model::DeleteResourcePolicyStatementOutcome DeleteResourcePolicyStatement(const Model::DeleteResourcePolicyStatementRequest& request) const; /** * A Callable wrapper for DeleteResourcePolicyStatement that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteResourcePolicyStatementOutcomeCallable DeleteResourcePolicyStatementCallable(const DeleteResourcePolicyStatementRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DeleteResourcePolicyStatement, request); } /** * An Async wrapper for DeleteResourcePolicyStatement that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteResourcePolicyStatementAsync(const DeleteResourcePolicyStatementRequestT& request, const DeleteResourcePolicyStatementResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DeleteResourcePolicyStatement, request, handler, context); } /** *

Deletes the specified slot from an intent.

See Also:

AWS * API Reference

*/ virtual Model::DeleteSlotOutcome DeleteSlot(const Model::DeleteSlotRequest& request) const; /** * A Callable wrapper for DeleteSlot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteSlotOutcomeCallable DeleteSlotCallable(const DeleteSlotRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DeleteSlot, request); } /** * An Async wrapper for DeleteSlot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteSlotAsync(const DeleteSlotRequestT& request, const DeleteSlotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DeleteSlot, request, handler, context); } /** *

Deletes a slot type from a bot locale.

If a slot is using the slot * type, Amazon Lex throws a ResourceInUseException exception. To * avoid the exception, set the skipResourceInUseCheck parameter to * true.

See Also:

AWS * API Reference

*/ virtual Model::DeleteSlotTypeOutcome DeleteSlotType(const Model::DeleteSlotTypeRequest& request) const; /** * A Callable wrapper for DeleteSlotType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteSlotTypeOutcomeCallable DeleteSlotTypeCallable(const DeleteSlotTypeRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DeleteSlotType, request); } /** * An Async wrapper for DeleteSlotType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteSlotTypeAsync(const DeleteSlotTypeRequestT& request, const DeleteSlotTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DeleteSlotType, request, handler, context); } /** *

The action to delete the selected test set.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTestSetOutcome DeleteTestSet(const Model::DeleteTestSetRequest& request) const; /** * A Callable wrapper for DeleteTestSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTestSetOutcomeCallable DeleteTestSetCallable(const DeleteTestSetRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DeleteTestSet, request); } /** * An Async wrapper for DeleteTestSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTestSetAsync(const DeleteTestSetRequestT& request, const DeleteTestSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DeleteTestSet, request, handler, context); } /** *

Deletes stored utterances.

Amazon Lex stores the utterances that users * send to your bot. Utterances are stored for 15 days for use with the ListAggregatedUtterances * 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 utterances for a specific session. 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 ListAggregatedUtterances operation are * deleted after 15 days.

See Also:

AWS * API Reference

*/ virtual Model::DeleteUtterancesOutcome DeleteUtterances(const Model::DeleteUtterancesRequest& request) const; /** * A Callable wrapper for DeleteUtterances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteUtterancesOutcomeCallable DeleteUtterancesCallable(const DeleteUtterancesRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DeleteUtterances, request); } /** * An Async wrapper for DeleteUtterances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteUtterancesAsync(const DeleteUtterancesRequestT& request, const DeleteUtterancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DeleteUtterances, request, handler, context); } /** *

Provides metadata information about a bot.

See Also:

AWS * API Reference

*/ virtual Model::DescribeBotOutcome DescribeBot(const Model::DescribeBotRequest& request) const; /** * A Callable wrapper for DescribeBot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeBotOutcomeCallable DescribeBotCallable(const DescribeBotRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DescribeBot, request); } /** * An Async wrapper for DescribeBot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeBotAsync(const DescribeBotRequestT& request, const DescribeBotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DescribeBot, request, handler, context); } /** *

Get information about a specific bot alias.

See Also:

AWS * API Reference

*/ virtual Model::DescribeBotAliasOutcome DescribeBotAlias(const Model::DescribeBotAliasRequest& request) const; /** * A Callable wrapper for DescribeBotAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeBotAliasOutcomeCallable DescribeBotAliasCallable(const DescribeBotAliasRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DescribeBotAlias, request); } /** * An Async wrapper for DescribeBotAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeBotAliasAsync(const DescribeBotAliasRequestT& request, const DescribeBotAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DescribeBotAlias, request, handler, context); } /** *

Describes the settings that a bot has for a specific locale.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeBotLocaleOutcome DescribeBotLocale(const Model::DescribeBotLocaleRequest& request) const; /** * A Callable wrapper for DescribeBotLocale that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeBotLocaleOutcomeCallable DescribeBotLocaleCallable(const DescribeBotLocaleRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DescribeBotLocale, request); } /** * An Async wrapper for DescribeBotLocale that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeBotLocaleAsync(const DescribeBotLocaleRequestT& request, const DescribeBotLocaleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DescribeBotLocale, request, handler, context); } /** *

Provides metadata information about a bot recommendation. This information * will enable you to get a description on the request inputs, to download * associated transcripts after processing is complete, and to download intents and * slot-types generated by the bot recommendation.

See Also:

AWS * API Reference

*/ virtual Model::DescribeBotRecommendationOutcome DescribeBotRecommendation(const Model::DescribeBotRecommendationRequest& request) const; /** * A Callable wrapper for DescribeBotRecommendation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeBotRecommendationOutcomeCallable DescribeBotRecommendationCallable(const DescribeBotRecommendationRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DescribeBotRecommendation, request); } /** * An Async wrapper for DescribeBotRecommendation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeBotRecommendationAsync(const DescribeBotRecommendationRequestT& request, const DescribeBotRecommendationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DescribeBotRecommendation, request, handler, context); } /** *

Provides metadata about a version of a bot.

See Also:

AWS * API Reference

*/ virtual Model::DescribeBotVersionOutcome DescribeBotVersion(const Model::DescribeBotVersionRequest& request) const; /** * A Callable wrapper for DescribeBotVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeBotVersionOutcomeCallable DescribeBotVersionCallable(const DescribeBotVersionRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DescribeBotVersion, request); } /** * An Async wrapper for DescribeBotVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeBotVersionAsync(const DescribeBotVersionRequestT& request, const DescribeBotVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DescribeBotVersion, request, handler, context); } /** *

Provides metadata information about a custom vocabulary.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeCustomVocabularyMetadataOutcome DescribeCustomVocabularyMetadata(const Model::DescribeCustomVocabularyMetadataRequest& request) const; /** * A Callable wrapper for DescribeCustomVocabularyMetadata that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCustomVocabularyMetadataOutcomeCallable DescribeCustomVocabularyMetadataCallable(const DescribeCustomVocabularyMetadataRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DescribeCustomVocabularyMetadata, request); } /** * An Async wrapper for DescribeCustomVocabularyMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCustomVocabularyMetadataAsync(const DescribeCustomVocabularyMetadataRequestT& request, const DescribeCustomVocabularyMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DescribeCustomVocabularyMetadata, request, handler, context); } /** *

Gets information about a specific export.

See Also:

AWS * API Reference

*/ virtual Model::DescribeExportOutcome DescribeExport(const Model::DescribeExportRequest& request) const; /** * A Callable wrapper for DescribeExport that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeExportOutcomeCallable DescribeExportCallable(const DescribeExportRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DescribeExport, request); } /** * An Async wrapper for DescribeExport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeExportAsync(const DescribeExportRequestT& request, const DescribeExportResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DescribeExport, request, handler, context); } /** *

Gets information about a specific import.

See Also:

AWS * API Reference

*/ virtual Model::DescribeImportOutcome DescribeImport(const Model::DescribeImportRequest& request) const; /** * A Callable wrapper for DescribeImport that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeImportOutcomeCallable DescribeImportCallable(const DescribeImportRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DescribeImport, request); } /** * An Async wrapper for DescribeImport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeImportAsync(const DescribeImportRequestT& request, const DescribeImportResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DescribeImport, request, handler, context); } /** *

Returns metadata about an intent.

See Also:

AWS * API Reference

*/ virtual Model::DescribeIntentOutcome DescribeIntent(const Model::DescribeIntentRequest& request) const; /** * A Callable wrapper for DescribeIntent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeIntentOutcomeCallable DescribeIntentCallable(const DescribeIntentRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DescribeIntent, request); } /** * An Async wrapper for DescribeIntent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeIntentAsync(const DescribeIntentRequestT& request, const DescribeIntentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DescribeIntent, request, handler, context); } /** *

Gets the resource policy and policy revision for a bot or bot * alias.

See Also:

AWS * API Reference

*/ virtual Model::DescribeResourcePolicyOutcome DescribeResourcePolicy(const Model::DescribeResourcePolicyRequest& request) const; /** * A Callable wrapper for DescribeResourcePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeResourcePolicyOutcomeCallable DescribeResourcePolicyCallable(const DescribeResourcePolicyRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DescribeResourcePolicy, request); } /** * An Async wrapper for DescribeResourcePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeResourcePolicyAsync(const DescribeResourcePolicyRequestT& request, const DescribeResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DescribeResourcePolicy, request, handler, context); } /** *

Gets metadata information about a slot.

See Also:

AWS * API Reference

*/ virtual Model::DescribeSlotOutcome DescribeSlot(const Model::DescribeSlotRequest& request) const; /** * A Callable wrapper for DescribeSlot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSlotOutcomeCallable DescribeSlotCallable(const DescribeSlotRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DescribeSlot, request); } /** * An Async wrapper for DescribeSlot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSlotAsync(const DescribeSlotRequestT& request, const DescribeSlotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DescribeSlot, request, handler, context); } /** *

Gets metadata information about a slot type.

See Also:

AWS * API Reference

*/ virtual Model::DescribeSlotTypeOutcome DescribeSlotType(const Model::DescribeSlotTypeRequest& request) const; /** * A Callable wrapper for DescribeSlotType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSlotTypeOutcomeCallable DescribeSlotTypeCallable(const DescribeSlotTypeRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DescribeSlotType, request); } /** * An Async wrapper for DescribeSlotType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSlotTypeAsync(const DescribeSlotTypeRequestT& request, const DescribeSlotTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DescribeSlotType, request, handler, context); } /** *

Gets metadata information about the test execution.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeTestExecutionOutcome DescribeTestExecution(const Model::DescribeTestExecutionRequest& request) const; /** * A Callable wrapper for DescribeTestExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTestExecutionOutcomeCallable DescribeTestExecutionCallable(const DescribeTestExecutionRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DescribeTestExecution, request); } /** * An Async wrapper for DescribeTestExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTestExecutionAsync(const DescribeTestExecutionRequestT& request, const DescribeTestExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DescribeTestExecution, request, handler, context); } /** *

Gets metadata information about the test set.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTestSetOutcome DescribeTestSet(const Model::DescribeTestSetRequest& request) const; /** * A Callable wrapper for DescribeTestSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTestSetOutcomeCallable DescribeTestSetCallable(const DescribeTestSetRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DescribeTestSet, request); } /** * An Async wrapper for DescribeTestSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTestSetAsync(const DescribeTestSetRequestT& request, const DescribeTestSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DescribeTestSet, request, handler, context); } /** *

Gets metadata information about the test set discrepancy * report.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTestSetDiscrepancyReportOutcome DescribeTestSetDiscrepancyReport(const Model::DescribeTestSetDiscrepancyReportRequest& request) const; /** * A Callable wrapper for DescribeTestSetDiscrepancyReport that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTestSetDiscrepancyReportOutcomeCallable DescribeTestSetDiscrepancyReportCallable(const DescribeTestSetDiscrepancyReportRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DescribeTestSetDiscrepancyReport, request); } /** * An Async wrapper for DescribeTestSetDiscrepancyReport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTestSetDiscrepancyReportAsync(const DescribeTestSetDiscrepancyReportRequestT& request, const DescribeTestSetDiscrepancyReportResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DescribeTestSetDiscrepancyReport, request, handler, context); } /** *

Gets metadata information about the test set generation.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeTestSetGenerationOutcome DescribeTestSetGeneration(const Model::DescribeTestSetGenerationRequest& request) const; /** * A Callable wrapper for DescribeTestSetGeneration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTestSetGenerationOutcomeCallable DescribeTestSetGenerationCallable(const DescribeTestSetGenerationRequestT& request) const { return SubmitCallable(&LexModelsV2Client::DescribeTestSetGeneration, request); } /** * An Async wrapper for DescribeTestSetGeneration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTestSetGenerationAsync(const DescribeTestSetGenerationRequestT& request, const DescribeTestSetGenerationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::DescribeTestSetGeneration, request, handler, context); } /** *

The pre-signed Amazon S3 URL to download the test execution result * artifacts.

See Also:

AWS * API Reference

*/ virtual Model::GetTestExecutionArtifactsUrlOutcome GetTestExecutionArtifactsUrl(const Model::GetTestExecutionArtifactsUrlRequest& request) const; /** * A Callable wrapper for GetTestExecutionArtifactsUrl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetTestExecutionArtifactsUrlOutcomeCallable GetTestExecutionArtifactsUrlCallable(const GetTestExecutionArtifactsUrlRequestT& request) const { return SubmitCallable(&LexModelsV2Client::GetTestExecutionArtifactsUrl, request); } /** * An Async wrapper for GetTestExecutionArtifactsUrl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetTestExecutionArtifactsUrlAsync(const GetTestExecutionArtifactsUrlRequestT& request, const GetTestExecutionArtifactsUrlResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::GetTestExecutionArtifactsUrl, request, handler, context); } /** *

Provides a list of utterances that users have sent to the bot.

*

Utterances are aggregated by the text of the utterance. For example, all * instances where customers used the phrase "I want to order pizza" are aggregated * into the same line in the response.

You can see both detected utterances * and missed utterances. A detected utterance is where the bot properly recognized * the utterance and activated the associated intent. A missed utterance was not * recognized by the bot and didn't activate an intent.

Utterances can be * aggregated for a bot alias or for a bot version, but not both at the same * time.

Utterances statistics are not generated under the following * conditions:

  • The childDirected field was set to * true when the bot was created.

  • You are using slot obfuscation * with one or more slots.

  • You opted out of participating in * improving Amazon Lex.

See Also:

AWS * API Reference

*/ virtual Model::ListAggregatedUtterancesOutcome ListAggregatedUtterances(const Model::ListAggregatedUtterancesRequest& request) const; /** * A Callable wrapper for ListAggregatedUtterances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAggregatedUtterancesOutcomeCallable ListAggregatedUtterancesCallable(const ListAggregatedUtterancesRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListAggregatedUtterances, request); } /** * An Async wrapper for ListAggregatedUtterances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAggregatedUtterancesAsync(const ListAggregatedUtterancesRequestT& request, const ListAggregatedUtterancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListAggregatedUtterances, request, handler, context); } /** *

Gets a list of aliases for the specified bot.

See Also:

AWS * API Reference

*/ virtual Model::ListBotAliasesOutcome ListBotAliases(const Model::ListBotAliasesRequest& request) const; /** * A Callable wrapper for ListBotAliases that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListBotAliasesOutcomeCallable ListBotAliasesCallable(const ListBotAliasesRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListBotAliases, request); } /** * An Async wrapper for ListBotAliases that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListBotAliasesAsync(const ListBotAliasesRequestT& request, const ListBotAliasesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListBotAliases, request, handler, context); } /** *

Gets a list of locales for the specified bot.

See Also:

AWS * API Reference

*/ virtual Model::ListBotLocalesOutcome ListBotLocales(const Model::ListBotLocalesRequest& request) const; /** * A Callable wrapper for ListBotLocales that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListBotLocalesOutcomeCallable ListBotLocalesCallable(const ListBotLocalesRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListBotLocales, request); } /** * An Async wrapper for ListBotLocales that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListBotLocalesAsync(const ListBotLocalesRequestT& request, const ListBotLocalesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListBotLocales, request, handler, context); } /** *

Get a list of bot recommendations that meet the specified * criteria.

See Also:

AWS * API Reference

*/ virtual Model::ListBotRecommendationsOutcome ListBotRecommendations(const Model::ListBotRecommendationsRequest& request) const; /** * A Callable wrapper for ListBotRecommendations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListBotRecommendationsOutcomeCallable ListBotRecommendationsCallable(const ListBotRecommendationsRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListBotRecommendations, request); } /** * An Async wrapper for ListBotRecommendations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListBotRecommendationsAsync(const ListBotRecommendationsRequestT& request, const ListBotRecommendationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListBotRecommendations, request, handler, context); } /** *

Gets information about all of the versions of a bot.

The * ListBotVersions operation returns a summary of each version of a * bot. For example, if a bot has three numbered versions, the * ListBotVersions operation returns for summaries, one for each * numbered version and one for the DRAFT version.

The * ListBotVersions operation always returns at least one version, the * DRAFT version.

See Also:

AWS * API Reference

*/ virtual Model::ListBotVersionsOutcome ListBotVersions(const Model::ListBotVersionsRequest& request) const; /** * A Callable wrapper for ListBotVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListBotVersionsOutcomeCallable ListBotVersionsCallable(const ListBotVersionsRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListBotVersions, request); } /** * An Async wrapper for ListBotVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListBotVersionsAsync(const ListBotVersionsRequestT& request, const ListBotVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListBotVersions, request, handler, context); } /** *

Gets a list of available bots.

See Also:

AWS * API Reference

*/ virtual Model::ListBotsOutcome ListBots(const Model::ListBotsRequest& request) const; /** * A Callable wrapper for ListBots that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListBotsOutcomeCallable ListBotsCallable(const ListBotsRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListBots, request); } /** * An Async wrapper for ListBots that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListBotsAsync(const ListBotsRequestT& request, const ListBotsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListBots, request, handler, context); } /** *

Gets a list of built-in intents provided by Amazon Lex that you can use in * your bot.

To use a built-in intent as a the base for your own intent, * include the built-in intent signature in the parentIntentSignature * parameter when you call the CreateIntent operation. For more * information, see CreateIntent.

See * Also:

AWS * API Reference

*/ virtual Model::ListBuiltInIntentsOutcome ListBuiltInIntents(const Model::ListBuiltInIntentsRequest& request) const; /** * A Callable wrapper for ListBuiltInIntents that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListBuiltInIntentsOutcomeCallable ListBuiltInIntentsCallable(const ListBuiltInIntentsRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListBuiltInIntents, request); } /** * An Async wrapper for ListBuiltInIntents that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListBuiltInIntentsAsync(const ListBuiltInIntentsRequestT& request, const ListBuiltInIntentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListBuiltInIntents, request, handler, context); } /** *

Gets a list of built-in slot types that meet the specified * criteria.

See Also:

AWS * API Reference

*/ virtual Model::ListBuiltInSlotTypesOutcome ListBuiltInSlotTypes(const Model::ListBuiltInSlotTypesRequest& request) const; /** * A Callable wrapper for ListBuiltInSlotTypes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListBuiltInSlotTypesOutcomeCallable ListBuiltInSlotTypesCallable(const ListBuiltInSlotTypesRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListBuiltInSlotTypes, request); } /** * An Async wrapper for ListBuiltInSlotTypes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListBuiltInSlotTypesAsync(const ListBuiltInSlotTypesRequestT& request, const ListBuiltInSlotTypesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListBuiltInSlotTypes, request, handler, context); } /** *

Paginated list of custom vocabulary items for a given bot locale's custom * vocabulary.

See Also:

AWS * API Reference

*/ virtual Model::ListCustomVocabularyItemsOutcome ListCustomVocabularyItems(const Model::ListCustomVocabularyItemsRequest& request) const; /** * A Callable wrapper for ListCustomVocabularyItems that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCustomVocabularyItemsOutcomeCallable ListCustomVocabularyItemsCallable(const ListCustomVocabularyItemsRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListCustomVocabularyItems, request); } /** * An Async wrapper for ListCustomVocabularyItems that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCustomVocabularyItemsAsync(const ListCustomVocabularyItemsRequestT& request, const ListCustomVocabularyItemsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListCustomVocabularyItems, request, handler, context); } /** *

Lists the exports for a bot, bot locale, or custom vocabulary. Exports are * kept in the list for 7 days.

See Also:

AWS * API Reference

*/ virtual Model::ListExportsOutcome ListExports(const Model::ListExportsRequest& request) const; /** * A Callable wrapper for ListExports that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListExportsOutcomeCallable ListExportsCallable(const ListExportsRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListExports, request); } /** * An Async wrapper for ListExports that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListExportsAsync(const ListExportsRequestT& request, const ListExportsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListExports, request, handler, context); } /** *

Lists the imports for a bot, bot locale, or custom vocabulary. Imports are * kept in the list for 7 days.

See Also:

AWS * API Reference

*/ virtual Model::ListImportsOutcome ListImports(const Model::ListImportsRequest& request) const; /** * A Callable wrapper for ListImports that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListImportsOutcomeCallable ListImportsCallable(const ListImportsRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListImports, request); } /** * An Async wrapper for ListImports that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListImportsAsync(const ListImportsRequestT& request, const ListImportsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListImports, request, handler, context); } /** *

Retrieves summary metrics for the intents in your bot. The following fields * are required:

  • metrics – A list of AnalyticsIntentMetric * objects. In each object, use the name field to specify the metric * to calculate, the statistic field to specify whether to calculate * the Sum, Average, or Max number, and the * order field to specify whether to sort the results in * Ascending or Descending order.

  • * startDateTime and endDateTime – Define a time range * for which you want to retrieve results.

Of the optional * fields, you can organize the results in the following ways:

  • Use * the filters field to filter the results, the groupBy * field to specify categories by which to group the results, and the * binBy field to specify time intervals by which to group the * results.

  • Use the maxResults field to limit the * number of results to return in a single response and the nextToken * field to return the next batch of results if the response does not return the * full set of results.

Note that an order field * exists in both binBy and metrics. You can specify only * one order in a given request.

See Also:

AWS * API Reference

*/ virtual Model::ListIntentMetricsOutcome ListIntentMetrics(const Model::ListIntentMetricsRequest& request) const; /** * A Callable wrapper for ListIntentMetrics that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListIntentMetricsOutcomeCallable ListIntentMetricsCallable(const ListIntentMetricsRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListIntentMetrics, request); } /** * An Async wrapper for ListIntentMetrics that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListIntentMetricsAsync(const ListIntentMetricsRequestT& request, const ListIntentMetricsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListIntentMetrics, request, handler, context); } /** *

Retrieves summary statistics for a path of intents that users take over * sessions with your bot. The following fields are required:

  • * startDateTime and endDateTime – Define a time range * for which you want to retrieve results.

  • * intentPath – Define an order of intents for which you want to * retrieve metrics. Separate intents in the path with a forward slash. For * example, populate the intentPath field with * /BookCar/BookHotel to see details about how many times users * invoked the BookCar and BookHotel intents in that * order.

Use the optional filters field to filter * the results.

See Also:

AWS * API Reference

*/ virtual Model::ListIntentPathsOutcome ListIntentPaths(const Model::ListIntentPathsRequest& request) const; /** * A Callable wrapper for ListIntentPaths that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListIntentPathsOutcomeCallable ListIntentPathsCallable(const ListIntentPathsRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListIntentPaths, request); } /** * An Async wrapper for ListIntentPaths that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListIntentPathsAsync(const ListIntentPathsRequestT& request, const ListIntentPathsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListIntentPaths, request, handler, context); } /** *

Retrieves summary metrics for the stages within intents in your bot. The * following fields are required:

  • metrics – A list * of AnalyticsIntentStageMetric * objects. In each object, use the name field to specify the metric * to calculate, the statistic field to specify whether to calculate * the Sum, Average, or Max number, and the * order field to specify whether to sort the results in * Ascending or Descending order.

  • * startDateTime and endDateTime – Define a time range * for which you want to retrieve results.

Of the optional * fields, you can organize the results in the following ways:

  • Use * the filters field to filter the results, the groupBy * field to specify categories by which to group the results, and the * binBy field to specify time intervals by which to group the * results.

  • Use the maxResults field to limit the * number of results to return in a single response and the nextToken * field to return the next batch of results if the response does not return the * full set of results.

Note that an order field * exists in both binBy and metrics. You can only specify * one order in a given request.

See Also:

AWS * API Reference

*/ virtual Model::ListIntentStageMetricsOutcome ListIntentStageMetrics(const Model::ListIntentStageMetricsRequest& request) const; /** * A Callable wrapper for ListIntentStageMetrics that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListIntentStageMetricsOutcomeCallable ListIntentStageMetricsCallable(const ListIntentStageMetricsRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListIntentStageMetrics, request); } /** * An Async wrapper for ListIntentStageMetrics that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListIntentStageMetricsAsync(const ListIntentStageMetricsRequestT& request, const ListIntentStageMetricsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListIntentStageMetrics, request, handler, context); } /** *

Get a list of intents that meet the specified criteria.

See * Also:

AWS * API Reference

*/ virtual Model::ListIntentsOutcome ListIntents(const Model::ListIntentsRequest& request) const; /** * A Callable wrapper for ListIntents that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListIntentsOutcomeCallable ListIntentsCallable(const ListIntentsRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListIntents, request); } /** * An Async wrapper for ListIntents that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListIntentsAsync(const ListIntentsRequestT& request, const ListIntentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListIntents, request, handler, context); } /** *

Gets a list of recommended intents provided by the bot recommendation that * you can use in your bot. Intents in the response are ordered by * relevance.

See Also:

AWS * API Reference

*/ virtual Model::ListRecommendedIntentsOutcome ListRecommendedIntents(const Model::ListRecommendedIntentsRequest& request) const; /** * A Callable wrapper for ListRecommendedIntents that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListRecommendedIntentsOutcomeCallable ListRecommendedIntentsCallable(const ListRecommendedIntentsRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListRecommendedIntents, request); } /** * An Async wrapper for ListRecommendedIntents that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListRecommendedIntentsAsync(const ListRecommendedIntentsRequestT& request, const ListRecommendedIntentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListRecommendedIntents, request, handler, context); } /** *

Retrieves a list of metadata for individual user sessions with your bot. The * startDateTime and endDateTime fields are required. * These fields define a time range for which you want to retrieve results. Of the * optional fields, you can organize the results in the following ways:

    *

  • Use the filters field to filter the results and the * sortBy field to specify the values by which to sort the * results.

  • Use the maxResults field to limit the * number of results to return in a single response and the nextToken * field to return the next batch of results if the response does not return the * full set of results.

See Also:

AWS * API Reference

*/ virtual Model::ListSessionAnalyticsDataOutcome ListSessionAnalyticsData(const Model::ListSessionAnalyticsDataRequest& request) const; /** * A Callable wrapper for ListSessionAnalyticsData that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSessionAnalyticsDataOutcomeCallable ListSessionAnalyticsDataCallable(const ListSessionAnalyticsDataRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListSessionAnalyticsData, request); } /** * An Async wrapper for ListSessionAnalyticsData that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSessionAnalyticsDataAsync(const ListSessionAnalyticsDataRequestT& request, const ListSessionAnalyticsDataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListSessionAnalyticsData, request, handler, context); } /** *

Retrieves summary metrics for the user sessions with your bot. The following * fields are required:

  • metrics – A list of AnalyticsSessionMetric * objects. In each object, use the name field to specify the metric * to calculate, the statistic field to specify whether to calculate * the Sum, Average, or Max number, and the * order field to specify whether to sort the results in * Ascending or Descending order.

  • * startDateTime and endDateTime – Define a time range * for which you want to retrieve results.

Of the optional * fields, you can organize the results in the following ways:

  • Use * the filters field to filter the results, the groupBy * field to specify categories by which to group the results, and the * binBy field to specify time intervals by which to group the * results.

  • Use the maxResults field to limit the * number of results to return in a single response and the nextToken * field to return the next batch of results if the response does not return the * full set of results.

Note that an order field * exists in both binBy and metrics. Currently, you can * specify it in either field, but not in both.

See Also:

AWS * API Reference

*/ virtual Model::ListSessionMetricsOutcome ListSessionMetrics(const Model::ListSessionMetricsRequest& request) const; /** * A Callable wrapper for ListSessionMetrics that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSessionMetricsOutcomeCallable ListSessionMetricsCallable(const ListSessionMetricsRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListSessionMetrics, request); } /** * An Async wrapper for ListSessionMetrics that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSessionMetricsAsync(const ListSessionMetricsRequestT& request, const ListSessionMetricsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListSessionMetrics, request, handler, context); } /** *

Gets a list of slot types that match the specified criteria.

See * Also:

AWS * API Reference

*/ virtual Model::ListSlotTypesOutcome ListSlotTypes(const Model::ListSlotTypesRequest& request) const; /** * A Callable wrapper for ListSlotTypes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSlotTypesOutcomeCallable ListSlotTypesCallable(const ListSlotTypesRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListSlotTypes, request); } /** * An Async wrapper for ListSlotTypes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSlotTypesAsync(const ListSlotTypesRequestT& request, const ListSlotTypesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListSlotTypes, request, handler, context); } /** *

Gets a list of slots that match the specified criteria.

See * Also:

AWS * API Reference

*/ virtual Model::ListSlotsOutcome ListSlots(const Model::ListSlotsRequest& request) const; /** * A Callable wrapper for ListSlots that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSlotsOutcomeCallable ListSlotsCallable(const ListSlotsRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListSlots, request); } /** * An Async wrapper for ListSlots that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSlotsAsync(const ListSlotsRequestT& request, const ListSlotsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListSlots, request, handler, context); } /** *

Gets a list of tags associated with a resource. Only bots, bot aliases, and * bot channels can have tags associated with them.

See Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListTagsForResource, request, handler, context); } /** *

Gets a list of test execution result items.

See Also:

AWS * API Reference

*/ virtual Model::ListTestExecutionResultItemsOutcome ListTestExecutionResultItems(const Model::ListTestExecutionResultItemsRequest& request) const; /** * A Callable wrapper for ListTestExecutionResultItems that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTestExecutionResultItemsOutcomeCallable ListTestExecutionResultItemsCallable(const ListTestExecutionResultItemsRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListTestExecutionResultItems, request); } /** * An Async wrapper for ListTestExecutionResultItems that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTestExecutionResultItemsAsync(const ListTestExecutionResultItemsRequestT& request, const ListTestExecutionResultItemsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListTestExecutionResultItems, request, handler, context); } /** *

The list of test set executions.

See Also:

AWS * API Reference

*/ virtual Model::ListTestExecutionsOutcome ListTestExecutions(const Model::ListTestExecutionsRequest& request) const; /** * A Callable wrapper for ListTestExecutions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTestExecutionsOutcomeCallable ListTestExecutionsCallable(const ListTestExecutionsRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListTestExecutions, request); } /** * An Async wrapper for ListTestExecutions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTestExecutionsAsync(const ListTestExecutionsRequestT& request, const ListTestExecutionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListTestExecutions, request, handler, context); } /** *

The list of test set records.

See Also:

AWS * API Reference

*/ virtual Model::ListTestSetRecordsOutcome ListTestSetRecords(const Model::ListTestSetRecordsRequest& request) const; /** * A Callable wrapper for ListTestSetRecords that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTestSetRecordsOutcomeCallable ListTestSetRecordsCallable(const ListTestSetRecordsRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListTestSetRecords, request); } /** * An Async wrapper for ListTestSetRecords that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTestSetRecordsAsync(const ListTestSetRecordsRequestT& request, const ListTestSetRecordsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListTestSetRecords, request, handler, context); } /** *

The list of the test sets

See Also:

AWS * API Reference

*/ virtual Model::ListTestSetsOutcome ListTestSets(const Model::ListTestSetsRequest& request) const; /** * A Callable wrapper for ListTestSets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTestSetsOutcomeCallable ListTestSetsCallable(const ListTestSetsRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListTestSets, request); } /** * An Async wrapper for ListTestSets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTestSetsAsync(const ListTestSetsRequestT& request, const ListTestSetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListTestSets, request, handler, context); } /** *

To use this API operation, your IAM role must have permissions to * perform the ListAggregatedUtterances * operation, which provides access to utterance-related analytics. See Viewing * utterance statistics for the IAM policy to apply to the IAM role.

*

Retrieves a list of metadata for individual user utterances to your * bot. The following fields are required:

  • * startDateTime and endDateTime – Define a time range * for which you want to retrieve results.

Of the optional * fields, you can organize the results in the following ways:

  • Use * the filters field to filter the results and the sortBy * field to specify the values by which to sort the results.

  • Use * the maxResults field to limit the number of results to return in a * single response and the nextToken field to return the next batch of * results if the response does not return the full set of results.

    • *

See Also:

AWS * API Reference

*/ virtual Model::ListUtteranceAnalyticsDataOutcome ListUtteranceAnalyticsData(const Model::ListUtteranceAnalyticsDataRequest& request) const; /** * A Callable wrapper for ListUtteranceAnalyticsData that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListUtteranceAnalyticsDataOutcomeCallable ListUtteranceAnalyticsDataCallable(const ListUtteranceAnalyticsDataRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListUtteranceAnalyticsData, request); } /** * An Async wrapper for ListUtteranceAnalyticsData that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListUtteranceAnalyticsDataAsync(const ListUtteranceAnalyticsDataRequestT& request, const ListUtteranceAnalyticsDataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListUtteranceAnalyticsData, request, handler, context); } /** *

To use this API operation, your IAM role must have permissions to * perform the ListAggregatedUtterances * operation, which provides access to utterance-related analytics. See Viewing * utterance statistics for the IAM policy to apply to the IAM role.

*

Retrieves summary metrics for the utterances in your bot. The * following fields are required:

  • metrics – A list * of AnalyticsUtteranceMetric * objects. In each object, use the name field to specify the metric * to calculate, the statistic field to specify whether to calculate * the Sum, Average, or Max number, and the * order field to specify whether to sort the results in * Ascending or Descending order.

  • * startDateTime and endDateTime – Define a time range * for which you want to retrieve results.

Of the optional * fields, you can organize the results in the following ways:

  • Use * the filters field to filter the results, the groupBy * field to specify categories by which to group the results, and the * binBy field to specify time intervals by which to group the * results.

  • Use the maxResults field to limit the * number of results to return in a single response and the nextToken * field to return the next batch of results if the response does not return the * full set of results.

Note that an order field * exists in both binBy and metrics. Currently, you can * specify it in either field, but not in both.

See Also:

AWS * API Reference

*/ virtual Model::ListUtteranceMetricsOutcome ListUtteranceMetrics(const Model::ListUtteranceMetricsRequest& request) const; /** * A Callable wrapper for ListUtteranceMetrics that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListUtteranceMetricsOutcomeCallable ListUtteranceMetricsCallable(const ListUtteranceMetricsRequestT& request) const { return SubmitCallable(&LexModelsV2Client::ListUtteranceMetrics, request); } /** * An Async wrapper for ListUtteranceMetrics that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListUtteranceMetricsAsync(const ListUtteranceMetricsRequestT& request, const ListUtteranceMetricsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::ListUtteranceMetrics, request, handler, context); } /** *

Search for associated transcripts that meet the specified * criteria.

See Also:

AWS * API Reference

*/ virtual Model::SearchAssociatedTranscriptsOutcome SearchAssociatedTranscripts(const Model::SearchAssociatedTranscriptsRequest& request) const; /** * A Callable wrapper for SearchAssociatedTranscripts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SearchAssociatedTranscriptsOutcomeCallable SearchAssociatedTranscriptsCallable(const SearchAssociatedTranscriptsRequestT& request) const { return SubmitCallable(&LexModelsV2Client::SearchAssociatedTranscripts, request); } /** * An Async wrapper for SearchAssociatedTranscripts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SearchAssociatedTranscriptsAsync(const SearchAssociatedTranscriptsRequestT& request, const SearchAssociatedTranscriptsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::SearchAssociatedTranscripts, request, handler, context); } /** *

Use this to provide your transcript data, and to start the bot recommendation * process.

See Also:

AWS * API Reference

*/ virtual Model::StartBotRecommendationOutcome StartBotRecommendation(const Model::StartBotRecommendationRequest& request) const; /** * A Callable wrapper for StartBotRecommendation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartBotRecommendationOutcomeCallable StartBotRecommendationCallable(const StartBotRecommendationRequestT& request) const { return SubmitCallable(&LexModelsV2Client::StartBotRecommendation, request); } /** * An Async wrapper for StartBotRecommendation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartBotRecommendationAsync(const StartBotRecommendationRequestT& request, const StartBotRecommendationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::StartBotRecommendation, request, handler, context); } /** *

Starts importing a bot, bot locale, or custom vocabulary from a zip archive * that you uploaded to an S3 bucket.

See Also:

AWS * API Reference

*/ virtual Model::StartImportOutcome StartImport(const Model::StartImportRequest& request) const; /** * A Callable wrapper for StartImport that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartImportOutcomeCallable StartImportCallable(const StartImportRequestT& request) const { return SubmitCallable(&LexModelsV2Client::StartImport, request); } /** * An Async wrapper for StartImport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartImportAsync(const StartImportRequestT& request, const StartImportResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::StartImport, request, handler, context); } /** *

The action to start test set execution.

See Also:

AWS * API Reference

*/ virtual Model::StartTestExecutionOutcome StartTestExecution(const Model::StartTestExecutionRequest& request) const; /** * A Callable wrapper for StartTestExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartTestExecutionOutcomeCallable StartTestExecutionCallable(const StartTestExecutionRequestT& request) const { return SubmitCallable(&LexModelsV2Client::StartTestExecution, request); } /** * An Async wrapper for StartTestExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartTestExecutionAsync(const StartTestExecutionRequestT& request, const StartTestExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::StartTestExecution, request, handler, context); } /** *

The action to start the generation of test set.

See Also:

AWS * API Reference

*/ virtual Model::StartTestSetGenerationOutcome StartTestSetGeneration(const Model::StartTestSetGenerationRequest& request) const; /** * A Callable wrapper for StartTestSetGeneration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartTestSetGenerationOutcomeCallable StartTestSetGenerationCallable(const StartTestSetGenerationRequestT& request) const { return SubmitCallable(&LexModelsV2Client::StartTestSetGeneration, request); } /** * An Async wrapper for StartTestSetGeneration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartTestSetGenerationAsync(const StartTestSetGenerationRequestT& request, const StartTestSetGenerationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::StartTestSetGeneration, request, handler, context); } /** *

Stop an already running Bot Recommendation request.

See Also:

* AWS * API Reference

*/ virtual Model::StopBotRecommendationOutcome StopBotRecommendation(const Model::StopBotRecommendationRequest& request) const; /** * A Callable wrapper for StopBotRecommendation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopBotRecommendationOutcomeCallable StopBotRecommendationCallable(const StopBotRecommendationRequestT& request) const { return SubmitCallable(&LexModelsV2Client::StopBotRecommendation, request); } /** * An Async wrapper for StopBotRecommendation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopBotRecommendationAsync(const StopBotRecommendationRequestT& request, const StopBotRecommendationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::StopBotRecommendation, request, handler, context); } /** *

Adds the specified tags to the specified resource. If a tag key already * exists, the existing value is replaced with the new value.

See * Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&LexModelsV2Client::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::TagResource, request, handler, context); } /** *

Removes tags from a bot, bot alias, or bot channel.

See Also:

* AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&LexModelsV2Client::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::UntagResource, request, handler, context); } /** *

Updates the configuration of an existing bot.

See Also:

AWS * API Reference

*/ virtual Model::UpdateBotOutcome UpdateBot(const Model::UpdateBotRequest& request) const; /** * A Callable wrapper for UpdateBot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateBotOutcomeCallable UpdateBotCallable(const UpdateBotRequestT& request) const { return SubmitCallable(&LexModelsV2Client::UpdateBot, request); } /** * An Async wrapper for UpdateBot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateBotAsync(const UpdateBotRequestT& request, const UpdateBotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::UpdateBot, request, handler, context); } /** *

Updates the configuration of an existing bot alias.

See Also:

* AWS * API Reference

*/ virtual Model::UpdateBotAliasOutcome UpdateBotAlias(const Model::UpdateBotAliasRequest& request) const; /** * A Callable wrapper for UpdateBotAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateBotAliasOutcomeCallable UpdateBotAliasCallable(const UpdateBotAliasRequestT& request) const { return SubmitCallable(&LexModelsV2Client::UpdateBotAlias, request); } /** * An Async wrapper for UpdateBotAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateBotAliasAsync(const UpdateBotAliasRequestT& request, const UpdateBotAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::UpdateBotAlias, request, handler, context); } /** *

Updates the settings that a bot has for a specific locale.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateBotLocaleOutcome UpdateBotLocale(const Model::UpdateBotLocaleRequest& request) const; /** * A Callable wrapper for UpdateBotLocale that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateBotLocaleOutcomeCallable UpdateBotLocaleCallable(const UpdateBotLocaleRequestT& request) const { return SubmitCallable(&LexModelsV2Client::UpdateBotLocale, request); } /** * An Async wrapper for UpdateBotLocale that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateBotLocaleAsync(const UpdateBotLocaleRequestT& request, const UpdateBotLocaleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::UpdateBotLocale, request, handler, context); } /** *

Updates an existing bot recommendation request.

See Also:

AWS * API Reference

*/ virtual Model::UpdateBotRecommendationOutcome UpdateBotRecommendation(const Model::UpdateBotRecommendationRequest& request) const; /** * A Callable wrapper for UpdateBotRecommendation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateBotRecommendationOutcomeCallable UpdateBotRecommendationCallable(const UpdateBotRecommendationRequestT& request) const { return SubmitCallable(&LexModelsV2Client::UpdateBotRecommendation, request); } /** * An Async wrapper for UpdateBotRecommendation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateBotRecommendationAsync(const UpdateBotRecommendationRequestT& request, const UpdateBotRecommendationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::UpdateBotRecommendation, request, handler, context); } /** *

Updates the password used to protect an export zip archive.

The * password is not required. If you don't supply a password, Amazon Lex generates a * zip file that is not protected by a password. This is the archive that is * available at the pre-signed S3 URL provided by the DescribeExport * operation.

See Also:

AWS * API Reference

*/ virtual Model::UpdateExportOutcome UpdateExport(const Model::UpdateExportRequest& request) const; /** * A Callable wrapper for UpdateExport that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateExportOutcomeCallable UpdateExportCallable(const UpdateExportRequestT& request) const { return SubmitCallable(&LexModelsV2Client::UpdateExport, request); } /** * An Async wrapper for UpdateExport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateExportAsync(const UpdateExportRequestT& request, const UpdateExportResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::UpdateExport, request, handler, context); } /** *

Updates the settings for an intent.

See Also:

AWS * API Reference

*/ virtual Model::UpdateIntentOutcome UpdateIntent(const Model::UpdateIntentRequest& request) const; /** * A Callable wrapper for UpdateIntent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateIntentOutcomeCallable UpdateIntentCallable(const UpdateIntentRequestT& request) const { return SubmitCallable(&LexModelsV2Client::UpdateIntent, request); } /** * An Async wrapper for UpdateIntent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateIntentAsync(const UpdateIntentRequestT& request, const UpdateIntentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::UpdateIntent, request, handler, context); } /** *

Replaces the existing resource policy for a bot or bot alias with a new one. * If the policy doesn't exist, Amazon Lex returns an exception.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateResourcePolicyOutcome UpdateResourcePolicy(const Model::UpdateResourcePolicyRequest& request) const; /** * A Callable wrapper for UpdateResourcePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateResourcePolicyOutcomeCallable UpdateResourcePolicyCallable(const UpdateResourcePolicyRequestT& request) const { return SubmitCallable(&LexModelsV2Client::UpdateResourcePolicy, request); } /** * An Async wrapper for UpdateResourcePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateResourcePolicyAsync(const UpdateResourcePolicyRequestT& request, const UpdateResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::UpdateResourcePolicy, request, handler, context); } /** *

Updates the settings for a slot.

See Also:

AWS * API Reference

*/ virtual Model::UpdateSlotOutcome UpdateSlot(const Model::UpdateSlotRequest& request) const; /** * A Callable wrapper for UpdateSlot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateSlotOutcomeCallable UpdateSlotCallable(const UpdateSlotRequestT& request) const { return SubmitCallable(&LexModelsV2Client::UpdateSlot, request); } /** * An Async wrapper for UpdateSlot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateSlotAsync(const UpdateSlotRequestT& request, const UpdateSlotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::UpdateSlot, request, handler, context); } /** *

Updates the configuration of an existing slot type.

See Also:

* AWS * API Reference

*/ virtual Model::UpdateSlotTypeOutcome UpdateSlotType(const Model::UpdateSlotTypeRequest& request) const; /** * A Callable wrapper for UpdateSlotType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateSlotTypeOutcomeCallable UpdateSlotTypeCallable(const UpdateSlotTypeRequestT& request) const { return SubmitCallable(&LexModelsV2Client::UpdateSlotType, request); } /** * An Async wrapper for UpdateSlotType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateSlotTypeAsync(const UpdateSlotTypeRequestT& request, const UpdateSlotTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::UpdateSlotType, request, handler, context); } /** *

The action to update the test set.

See Also:

AWS * API Reference

*/ virtual Model::UpdateTestSetOutcome UpdateTestSet(const Model::UpdateTestSetRequest& request) const; /** * A Callable wrapper for UpdateTestSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTestSetOutcomeCallable UpdateTestSetCallable(const UpdateTestSetRequestT& request) const { return SubmitCallable(&LexModelsV2Client::UpdateTestSet, request); } /** * An Async wrapper for UpdateTestSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTestSetAsync(const UpdateTestSetRequestT& request, const UpdateTestSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LexModelsV2Client::UpdateTestSet, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const LexModelsV2ClientConfiguration& clientConfiguration); LexModelsV2ClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace LexModelsV2 } // namespace Aws