LexModelsV2Client.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/lexv2-models/LexModelsV2PaginationBase.h>
#include <aws/lexv2-models/LexModelsV2ServiceClientModel.h>
#include <aws/lexv2-models/LexModelsV2_EXPORTS.h>
 
namespace Aws {
namespace LexModelsV2 {
class AWS_LEXMODELSV2_API LexModelsV2Client : public Aws::Client::AWSJsonClient,
                                              public Aws::Client::ClientWithAsyncTemplateMethods<LexModelsV2Client>,
                                              public LexModelsV2PaginationBase<LexModelsV2Client> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef LexModelsV2ClientConfiguration ClientConfigurationType;
  typedef LexModelsV2EndpointProvider EndpointProviderType;
 
  LexModelsV2Client(
      const Aws::LexModelsV2::LexModelsV2ClientConfiguration& clientConfiguration = Aws::LexModelsV2::LexModelsV2ClientConfiguration(),
      std::shared_ptr<LexModelsV2EndpointProviderBase> endpointProvider = nullptr);
 
  LexModelsV2Client(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<LexModelsV2EndpointProviderBase> endpointProvider = nullptr,
      const Aws::LexModelsV2::LexModelsV2ClientConfiguration& clientConfiguration = Aws::LexModelsV2::LexModelsV2ClientConfiguration());
 
  LexModelsV2Client(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<LexModelsV2EndpointProviderBase> endpointProvider = nullptr,
      const Aws::LexModelsV2::LexModelsV2ClientConfiguration& clientConfiguration = Aws::LexModelsV2::LexModelsV2ClientConfiguration());
 
  /* Legacy constructors due deprecation */
  LexModelsV2Client(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  LexModelsV2Client(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  LexModelsV2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                    const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~LexModelsV2Client();
 
  virtual Model::BatchCreateCustomVocabularyItemOutcome BatchCreateCustomVocabularyItem(
      const Model::BatchCreateCustomVocabularyItemRequest& request) const;
 
  template <typename BatchCreateCustomVocabularyItemRequestT = Model::BatchCreateCustomVocabularyItemRequest>
  Model::BatchCreateCustomVocabularyItemOutcomeCallable BatchCreateCustomVocabularyItemCallable(
      const BatchCreateCustomVocabularyItemRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::BatchCreateCustomVocabularyItem, request);
  }
 
  template <typename BatchCreateCustomVocabularyItemRequestT = Model::BatchCreateCustomVocabularyItemRequest>
  void BatchCreateCustomVocabularyItemAsync(const BatchCreateCustomVocabularyItemRequestT& request,
                                            const BatchCreateCustomVocabularyItemResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::BatchCreateCustomVocabularyItem, request, handler, context);
  }
 
  virtual Model::BatchDeleteCustomVocabularyItemOutcome BatchDeleteCustomVocabularyItem(
      const Model::BatchDeleteCustomVocabularyItemRequest& request) const;
 
  template <typename BatchDeleteCustomVocabularyItemRequestT = Model::BatchDeleteCustomVocabularyItemRequest>
  Model::BatchDeleteCustomVocabularyItemOutcomeCallable BatchDeleteCustomVocabularyItemCallable(
      const BatchDeleteCustomVocabularyItemRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::BatchDeleteCustomVocabularyItem, request);
  }
 
  template <typename BatchDeleteCustomVocabularyItemRequestT = Model::BatchDeleteCustomVocabularyItemRequest>
  void BatchDeleteCustomVocabularyItemAsync(const BatchDeleteCustomVocabularyItemRequestT& request,
                                            const BatchDeleteCustomVocabularyItemResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::BatchDeleteCustomVocabularyItem, request, handler, context);
  }
 
  virtual Model::BatchUpdateCustomVocabularyItemOutcome BatchUpdateCustomVocabularyItem(
      const Model::BatchUpdateCustomVocabularyItemRequest& request) const;
 
  template <typename BatchUpdateCustomVocabularyItemRequestT = Model::BatchUpdateCustomVocabularyItemRequest>
  Model::BatchUpdateCustomVocabularyItemOutcomeCallable BatchUpdateCustomVocabularyItemCallable(
      const BatchUpdateCustomVocabularyItemRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::BatchUpdateCustomVocabularyItem, request);
  }
 
  template <typename BatchUpdateCustomVocabularyItemRequestT = Model::BatchUpdateCustomVocabularyItemRequest>
  void BatchUpdateCustomVocabularyItemAsync(const BatchUpdateCustomVocabularyItemRequestT& request,
                                            const BatchUpdateCustomVocabularyItemResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::BatchUpdateCustomVocabularyItem, request, handler, context);
  }
 
  virtual Model::BuildBotLocaleOutcome BuildBotLocale(const Model::BuildBotLocaleRequest& request) const;
 
  template <typename BuildBotLocaleRequestT = Model::BuildBotLocaleRequest>
  Model::BuildBotLocaleOutcomeCallable BuildBotLocaleCallable(const BuildBotLocaleRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::BuildBotLocale, request);
  }
 
  template <typename BuildBotLocaleRequestT = Model::BuildBotLocaleRequest>
  void BuildBotLocaleAsync(const BuildBotLocaleRequestT& request, const BuildBotLocaleResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::BuildBotLocale, request, handler, context);
  }
 
  virtual Model::CreateBotOutcome CreateBot(const Model::CreateBotRequest& request) const;
 
  template <typename CreateBotRequestT = Model::CreateBotRequest>
  Model::CreateBotOutcomeCallable CreateBotCallable(const CreateBotRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::CreateBot, request);
  }
 
  template <typename CreateBotRequestT = Model::CreateBotRequest>
  void CreateBotAsync(const CreateBotRequestT& request, const CreateBotResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::CreateBot, request, handler, context);
  }
 
  virtual Model::CreateBotAliasOutcome CreateBotAlias(const Model::CreateBotAliasRequest& request) const;
 
  template <typename CreateBotAliasRequestT = Model::CreateBotAliasRequest>
  Model::CreateBotAliasOutcomeCallable CreateBotAliasCallable(const CreateBotAliasRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::CreateBotAlias, request);
  }
 
  template <typename CreateBotAliasRequestT = Model::CreateBotAliasRequest>
  void CreateBotAliasAsync(const CreateBotAliasRequestT& request, const CreateBotAliasResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::CreateBotAlias, request, handler, context);
  }
 
  virtual Model::CreateBotLocaleOutcome CreateBotLocale(const Model::CreateBotLocaleRequest& request) const;
 
  template <typename CreateBotLocaleRequestT = Model::CreateBotLocaleRequest>
  Model::CreateBotLocaleOutcomeCallable CreateBotLocaleCallable(const CreateBotLocaleRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::CreateBotLocale, request);
  }
 
  template <typename CreateBotLocaleRequestT = Model::CreateBotLocaleRequest>
  void CreateBotLocaleAsync(const CreateBotLocaleRequestT& request, const CreateBotLocaleResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::CreateBotLocale, request, handler, context);
  }
 
  virtual Model::CreateBotReplicaOutcome CreateBotReplica(const Model::CreateBotReplicaRequest& request) const;
 
  template <typename CreateBotReplicaRequestT = Model::CreateBotReplicaRequest>
  Model::CreateBotReplicaOutcomeCallable CreateBotReplicaCallable(const CreateBotReplicaRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::CreateBotReplica, request);
  }
 
  template <typename CreateBotReplicaRequestT = Model::CreateBotReplicaRequest>
  void CreateBotReplicaAsync(const CreateBotReplicaRequestT& request, const CreateBotReplicaResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::CreateBotReplica, request, handler, context);
  }
 
  virtual Model::CreateBotVersionOutcome CreateBotVersion(const Model::CreateBotVersionRequest& request) const;
 
  template <typename CreateBotVersionRequestT = Model::CreateBotVersionRequest>
  Model::CreateBotVersionOutcomeCallable CreateBotVersionCallable(const CreateBotVersionRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::CreateBotVersion, request);
  }
 
  template <typename CreateBotVersionRequestT = Model::CreateBotVersionRequest>
  void CreateBotVersionAsync(const CreateBotVersionRequestT& request, const CreateBotVersionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::CreateBotVersion, request, handler, context);
  }
 
  virtual Model::CreateExportOutcome CreateExport(const Model::CreateExportRequest& request) const;
 
  template <typename CreateExportRequestT = Model::CreateExportRequest>
  Model::CreateExportOutcomeCallable CreateExportCallable(const CreateExportRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::CreateExport, request);
  }
 
  template <typename CreateExportRequestT = Model::CreateExportRequest>
  void CreateExportAsync(const CreateExportRequestT& request, const CreateExportResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::CreateExport, request, handler, context);
  }
 
  virtual Model::CreateIntentOutcome CreateIntent(const Model::CreateIntentRequest& request) const;
 
  template <typename CreateIntentRequestT = Model::CreateIntentRequest>
  Model::CreateIntentOutcomeCallable CreateIntentCallable(const CreateIntentRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::CreateIntent, request);
  }
 
  template <typename CreateIntentRequestT = Model::CreateIntentRequest>
  void CreateIntentAsync(const CreateIntentRequestT& request, const CreateIntentResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::CreateIntent, request, handler, context);
  }
 
  virtual Model::CreateResourcePolicyOutcome CreateResourcePolicy(const Model::CreateResourcePolicyRequest& request) const;
 
  template <typename CreateResourcePolicyRequestT = Model::CreateResourcePolicyRequest>
  Model::CreateResourcePolicyOutcomeCallable CreateResourcePolicyCallable(const CreateResourcePolicyRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::CreateResourcePolicy, request);
  }
 
  template <typename CreateResourcePolicyRequestT = Model::CreateResourcePolicyRequest>
  void CreateResourcePolicyAsync(const CreateResourcePolicyRequestT& request, const CreateResourcePolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::CreateResourcePolicy, request, handler, context);
  }
 
  virtual Model::CreateResourcePolicyStatementOutcome CreateResourcePolicyStatement(
      const Model::CreateResourcePolicyStatementRequest& request) const;
 
  template <typename CreateResourcePolicyStatementRequestT = Model::CreateResourcePolicyStatementRequest>
  Model::CreateResourcePolicyStatementOutcomeCallable CreateResourcePolicyStatementCallable(
      const CreateResourcePolicyStatementRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::CreateResourcePolicyStatement, request);
  }
 
  template <typename CreateResourcePolicyStatementRequestT = Model::CreateResourcePolicyStatementRequest>
  void CreateResourcePolicyStatementAsync(const CreateResourcePolicyStatementRequestT& request,
                                          const CreateResourcePolicyStatementResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::CreateResourcePolicyStatement, request, handler, context);
  }
 
  virtual Model::CreateSlotOutcome CreateSlot(const Model::CreateSlotRequest& request) const;
 
  template <typename CreateSlotRequestT = Model::CreateSlotRequest>
  Model::CreateSlotOutcomeCallable CreateSlotCallable(const CreateSlotRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::CreateSlot, request);
  }
 
  template <typename CreateSlotRequestT = Model::CreateSlotRequest>
  void CreateSlotAsync(const CreateSlotRequestT& request, const CreateSlotResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::CreateSlot, request, handler, context);
  }
 
  virtual Model::CreateSlotTypeOutcome CreateSlotType(const Model::CreateSlotTypeRequest& request) const;
 
  template <typename CreateSlotTypeRequestT = Model::CreateSlotTypeRequest>
  Model::CreateSlotTypeOutcomeCallable CreateSlotTypeCallable(const CreateSlotTypeRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::CreateSlotType, request);
  }
 
  template <typename CreateSlotTypeRequestT = Model::CreateSlotTypeRequest>
  void CreateSlotTypeAsync(const CreateSlotTypeRequestT& request, const CreateSlotTypeResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::CreateSlotType, request, handler, context);
  }
 
  virtual Model::CreateTestSetDiscrepancyReportOutcome CreateTestSetDiscrepancyReport(
      const Model::CreateTestSetDiscrepancyReportRequest& request) const;
 
  template <typename CreateTestSetDiscrepancyReportRequestT = Model::CreateTestSetDiscrepancyReportRequest>
  Model::CreateTestSetDiscrepancyReportOutcomeCallable CreateTestSetDiscrepancyReportCallable(
      const CreateTestSetDiscrepancyReportRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::CreateTestSetDiscrepancyReport, request);
  }
 
  template <typename CreateTestSetDiscrepancyReportRequestT = Model::CreateTestSetDiscrepancyReportRequest>
  void CreateTestSetDiscrepancyReportAsync(const CreateTestSetDiscrepancyReportRequestT& request,
                                           const CreateTestSetDiscrepancyReportResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::CreateTestSetDiscrepancyReport, request, handler, context);
  }
 
  virtual Model::CreateUploadUrlOutcome CreateUploadUrl(const Model::CreateUploadUrlRequest& request = {}) const;
 
  template <typename CreateUploadUrlRequestT = Model::CreateUploadUrlRequest>
  Model::CreateUploadUrlOutcomeCallable CreateUploadUrlCallable(const CreateUploadUrlRequestT& request = {}) const {
    return SubmitCallable(&LexModelsV2Client::CreateUploadUrl, request);
  }
 
  template <typename CreateUploadUrlRequestT = Model::CreateUploadUrlRequest>
  void CreateUploadUrlAsync(const CreateUploadUrlResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const CreateUploadUrlRequestT& request = {}) const {
    return SubmitAsync(&LexModelsV2Client::CreateUploadUrl, request, handler, context);
  }
 
  virtual Model::DeleteBotOutcome DeleteBot(const Model::DeleteBotRequest& request) const;
 
  template <typename DeleteBotRequestT = Model::DeleteBotRequest>
  Model::DeleteBotOutcomeCallable DeleteBotCallable(const DeleteBotRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DeleteBot, request);
  }
 
  template <typename DeleteBotRequestT = Model::DeleteBotRequest>
  void DeleteBotAsync(const DeleteBotRequestT& request, const DeleteBotResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DeleteBot, request, handler, context);
  }
 
  virtual Model::DeleteBotAliasOutcome DeleteBotAlias(const Model::DeleteBotAliasRequest& request) const;
 
  template <typename DeleteBotAliasRequestT = Model::DeleteBotAliasRequest>
  Model::DeleteBotAliasOutcomeCallable DeleteBotAliasCallable(const DeleteBotAliasRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DeleteBotAlias, request);
  }
 
  template <typename DeleteBotAliasRequestT = Model::DeleteBotAliasRequest>
  void DeleteBotAliasAsync(const DeleteBotAliasRequestT& request, const DeleteBotAliasResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DeleteBotAlias, request, handler, context);
  }
 
  virtual Model::DeleteBotLocaleOutcome DeleteBotLocale(const Model::DeleteBotLocaleRequest& request) const;
 
  template <typename DeleteBotLocaleRequestT = Model::DeleteBotLocaleRequest>
  Model::DeleteBotLocaleOutcomeCallable DeleteBotLocaleCallable(const DeleteBotLocaleRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DeleteBotLocale, request);
  }
 
  template <typename DeleteBotLocaleRequestT = Model::DeleteBotLocaleRequest>
  void DeleteBotLocaleAsync(const DeleteBotLocaleRequestT& request, const DeleteBotLocaleResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DeleteBotLocale, request, handler, context);
  }
 
  virtual Model::DeleteBotReplicaOutcome DeleteBotReplica(const Model::DeleteBotReplicaRequest& request) const;
 
  template <typename DeleteBotReplicaRequestT = Model::DeleteBotReplicaRequest>
  Model::DeleteBotReplicaOutcomeCallable DeleteBotReplicaCallable(const DeleteBotReplicaRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DeleteBotReplica, request);
  }
 
  template <typename DeleteBotReplicaRequestT = Model::DeleteBotReplicaRequest>
  void DeleteBotReplicaAsync(const DeleteBotReplicaRequestT& request, const DeleteBotReplicaResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DeleteBotReplica, request, handler, context);
  }
 
  virtual Model::DeleteBotVersionOutcome DeleteBotVersion(const Model::DeleteBotVersionRequest& request) const;
 
  template <typename DeleteBotVersionRequestT = Model::DeleteBotVersionRequest>
  Model::DeleteBotVersionOutcomeCallable DeleteBotVersionCallable(const DeleteBotVersionRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DeleteBotVersion, request);
  }
 
  template <typename DeleteBotVersionRequestT = Model::DeleteBotVersionRequest>
  void DeleteBotVersionAsync(const DeleteBotVersionRequestT& request, const DeleteBotVersionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DeleteBotVersion, request, handler, context);
  }
 
  virtual Model::DeleteCustomVocabularyOutcome DeleteCustomVocabulary(const Model::DeleteCustomVocabularyRequest& request) const;
 
  template <typename DeleteCustomVocabularyRequestT = Model::DeleteCustomVocabularyRequest>
  Model::DeleteCustomVocabularyOutcomeCallable DeleteCustomVocabularyCallable(const DeleteCustomVocabularyRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DeleteCustomVocabulary, request);
  }
 
  template <typename DeleteCustomVocabularyRequestT = Model::DeleteCustomVocabularyRequest>
  void DeleteCustomVocabularyAsync(const DeleteCustomVocabularyRequestT& request,
                                   const DeleteCustomVocabularyResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DeleteCustomVocabulary, request, handler, context);
  }
 
  virtual Model::DeleteExportOutcome DeleteExport(const Model::DeleteExportRequest& request) const;
 
  template <typename DeleteExportRequestT = Model::DeleteExportRequest>
  Model::DeleteExportOutcomeCallable DeleteExportCallable(const DeleteExportRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DeleteExport, request);
  }
 
  template <typename DeleteExportRequestT = Model::DeleteExportRequest>
  void DeleteExportAsync(const DeleteExportRequestT& request, const DeleteExportResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DeleteExport, request, handler, context);
  }
 
  virtual Model::DeleteImportOutcome DeleteImport(const Model::DeleteImportRequest& request) const;
 
  template <typename DeleteImportRequestT = Model::DeleteImportRequest>
  Model::DeleteImportOutcomeCallable DeleteImportCallable(const DeleteImportRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DeleteImport, request);
  }
 
  template <typename DeleteImportRequestT = Model::DeleteImportRequest>
  void DeleteImportAsync(const DeleteImportRequestT& request, const DeleteImportResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DeleteImport, request, handler, context);
  }
 
  virtual Model::DeleteIntentOutcome DeleteIntent(const Model::DeleteIntentRequest& request) const;
 
  template <typename DeleteIntentRequestT = Model::DeleteIntentRequest>
  Model::DeleteIntentOutcomeCallable DeleteIntentCallable(const DeleteIntentRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DeleteIntent, request);
  }
 
  template <typename DeleteIntentRequestT = Model::DeleteIntentRequest>
  void DeleteIntentAsync(const DeleteIntentRequestT& request, const DeleteIntentResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DeleteIntent, request, handler, context);
  }
 
  virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request) const;
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DeleteResourcePolicy, request);
  }
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  void DeleteResourcePolicyAsync(const DeleteResourcePolicyRequestT& request, const DeleteResourcePolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DeleteResourcePolicy, request, handler, context);
  }
 
  virtual Model::DeleteResourcePolicyStatementOutcome DeleteResourcePolicyStatement(
      const Model::DeleteResourcePolicyStatementRequest& request) const;
 
  template <typename DeleteResourcePolicyStatementRequestT = Model::DeleteResourcePolicyStatementRequest>
  Model::DeleteResourcePolicyStatementOutcomeCallable DeleteResourcePolicyStatementCallable(
      const DeleteResourcePolicyStatementRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DeleteResourcePolicyStatement, request);
  }
 
  template <typename DeleteResourcePolicyStatementRequestT = Model::DeleteResourcePolicyStatementRequest>
  void DeleteResourcePolicyStatementAsync(const DeleteResourcePolicyStatementRequestT& request,
                                          const DeleteResourcePolicyStatementResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DeleteResourcePolicyStatement, request, handler, context);
  }
 
  virtual Model::DeleteSlotOutcome DeleteSlot(const Model::DeleteSlotRequest& request) const;
 
  template <typename DeleteSlotRequestT = Model::DeleteSlotRequest>
  Model::DeleteSlotOutcomeCallable DeleteSlotCallable(const DeleteSlotRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DeleteSlot, request);
  }
 
  template <typename DeleteSlotRequestT = Model::DeleteSlotRequest>
  void DeleteSlotAsync(const DeleteSlotRequestT& request, const DeleteSlotResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DeleteSlot, request, handler, context);
  }
 
  virtual Model::DeleteSlotTypeOutcome DeleteSlotType(const Model::DeleteSlotTypeRequest& request) const;
 
  template <typename DeleteSlotTypeRequestT = Model::DeleteSlotTypeRequest>
  Model::DeleteSlotTypeOutcomeCallable DeleteSlotTypeCallable(const DeleteSlotTypeRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DeleteSlotType, request);
  }
 
  template <typename DeleteSlotTypeRequestT = Model::DeleteSlotTypeRequest>
  void DeleteSlotTypeAsync(const DeleteSlotTypeRequestT& request, const DeleteSlotTypeResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DeleteSlotType, request, handler, context);
  }
 
  virtual Model::DeleteTestSetOutcome DeleteTestSet(const Model::DeleteTestSetRequest& request) const;
 
  template <typename DeleteTestSetRequestT = Model::DeleteTestSetRequest>
  Model::DeleteTestSetOutcomeCallable DeleteTestSetCallable(const DeleteTestSetRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DeleteTestSet, request);
  }
 
  template <typename DeleteTestSetRequestT = Model::DeleteTestSetRequest>
  void DeleteTestSetAsync(const DeleteTestSetRequestT& request, const DeleteTestSetResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DeleteTestSet, request, handler, context);
  }
 
  virtual Model::DeleteUtterancesOutcome DeleteUtterances(const Model::DeleteUtterancesRequest& request) const;
 
  template <typename DeleteUtterancesRequestT = Model::DeleteUtterancesRequest>
  Model::DeleteUtterancesOutcomeCallable DeleteUtterancesCallable(const DeleteUtterancesRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DeleteUtterances, request);
  }
 
  template <typename DeleteUtterancesRequestT = Model::DeleteUtterancesRequest>
  void DeleteUtterancesAsync(const DeleteUtterancesRequestT& request, const DeleteUtterancesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DeleteUtterances, request, handler, context);
  }
 
  virtual Model::DescribeBotOutcome DescribeBot(const Model::DescribeBotRequest& request) const;
 
  template <typename DescribeBotRequestT = Model::DescribeBotRequest>
  Model::DescribeBotOutcomeCallable DescribeBotCallable(const DescribeBotRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DescribeBot, request);
  }
 
  template <typename DescribeBotRequestT = Model::DescribeBotRequest>
  void DescribeBotAsync(const DescribeBotRequestT& request, const DescribeBotResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DescribeBot, request, handler, context);
  }
 
  virtual Model::DescribeBotAliasOutcome DescribeBotAlias(const Model::DescribeBotAliasRequest& request) const;
 
  template <typename DescribeBotAliasRequestT = Model::DescribeBotAliasRequest>
  Model::DescribeBotAliasOutcomeCallable DescribeBotAliasCallable(const DescribeBotAliasRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DescribeBotAlias, request);
  }
 
  template <typename DescribeBotAliasRequestT = Model::DescribeBotAliasRequest>
  void DescribeBotAliasAsync(const DescribeBotAliasRequestT& request, const DescribeBotAliasResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DescribeBotAlias, request, handler, context);
  }
 
  virtual Model::DescribeBotLocaleOutcome DescribeBotLocale(const Model::DescribeBotLocaleRequest& request) const;
 
  template <typename DescribeBotLocaleRequestT = Model::DescribeBotLocaleRequest>
  Model::DescribeBotLocaleOutcomeCallable DescribeBotLocaleCallable(const DescribeBotLocaleRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DescribeBotLocale, request);
  }
 
  template <typename DescribeBotLocaleRequestT = Model::DescribeBotLocaleRequest>
  void DescribeBotLocaleAsync(const DescribeBotLocaleRequestT& request, const DescribeBotLocaleResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DescribeBotLocale, request, handler, context);
  }
 
  virtual Model::DescribeBotRecommendationOutcome DescribeBotRecommendation(const Model::DescribeBotRecommendationRequest& request) const;
 
  template <typename DescribeBotRecommendationRequestT = Model::DescribeBotRecommendationRequest>
  Model::DescribeBotRecommendationOutcomeCallable DescribeBotRecommendationCallable(
      const DescribeBotRecommendationRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DescribeBotRecommendation, request);
  }
 
  template <typename DescribeBotRecommendationRequestT = Model::DescribeBotRecommendationRequest>
  void DescribeBotRecommendationAsync(const DescribeBotRecommendationRequestT& request,
                                      const DescribeBotRecommendationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DescribeBotRecommendation, request, handler, context);
  }
 
  virtual Model::DescribeBotReplicaOutcome DescribeBotReplica(const Model::DescribeBotReplicaRequest& request) const;
 
  template <typename DescribeBotReplicaRequestT = Model::DescribeBotReplicaRequest>
  Model::DescribeBotReplicaOutcomeCallable DescribeBotReplicaCallable(const DescribeBotReplicaRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DescribeBotReplica, request);
  }
 
  template <typename DescribeBotReplicaRequestT = Model::DescribeBotReplicaRequest>
  void DescribeBotReplicaAsync(const DescribeBotReplicaRequestT& request, const DescribeBotReplicaResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DescribeBotReplica, request, handler, context);
  }
 
  virtual Model::DescribeBotResourceGenerationOutcome DescribeBotResourceGeneration(
      const Model::DescribeBotResourceGenerationRequest& request) const;
 
  template <typename DescribeBotResourceGenerationRequestT = Model::DescribeBotResourceGenerationRequest>
  Model::DescribeBotResourceGenerationOutcomeCallable DescribeBotResourceGenerationCallable(
      const DescribeBotResourceGenerationRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DescribeBotResourceGeneration, request);
  }
 
  template <typename DescribeBotResourceGenerationRequestT = Model::DescribeBotResourceGenerationRequest>
  void DescribeBotResourceGenerationAsync(const DescribeBotResourceGenerationRequestT& request,
                                          const DescribeBotResourceGenerationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DescribeBotResourceGeneration, request, handler, context);
  }
 
  virtual Model::DescribeBotVersionOutcome DescribeBotVersion(const Model::DescribeBotVersionRequest& request) const;
 
  template <typename DescribeBotVersionRequestT = Model::DescribeBotVersionRequest>
  Model::DescribeBotVersionOutcomeCallable DescribeBotVersionCallable(const DescribeBotVersionRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DescribeBotVersion, request);
  }
 
  template <typename DescribeBotVersionRequestT = Model::DescribeBotVersionRequest>
  void DescribeBotVersionAsync(const DescribeBotVersionRequestT& request, const DescribeBotVersionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DescribeBotVersion, request, handler, context);
  }
 
  virtual Model::DescribeCustomVocabularyMetadataOutcome DescribeCustomVocabularyMetadata(
      const Model::DescribeCustomVocabularyMetadataRequest& request) const;
 
  template <typename DescribeCustomVocabularyMetadataRequestT = Model::DescribeCustomVocabularyMetadataRequest>
  Model::DescribeCustomVocabularyMetadataOutcomeCallable DescribeCustomVocabularyMetadataCallable(
      const DescribeCustomVocabularyMetadataRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DescribeCustomVocabularyMetadata, request);
  }
 
  template <typename DescribeCustomVocabularyMetadataRequestT = Model::DescribeCustomVocabularyMetadataRequest>
  void DescribeCustomVocabularyMetadataAsync(const DescribeCustomVocabularyMetadataRequestT& request,
                                             const DescribeCustomVocabularyMetadataResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DescribeCustomVocabularyMetadata, request, handler, context);
  }
 
  virtual Model::DescribeExportOutcome DescribeExport(const Model::DescribeExportRequest& request) const;
 
  template <typename DescribeExportRequestT = Model::DescribeExportRequest>
  Model::DescribeExportOutcomeCallable DescribeExportCallable(const DescribeExportRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DescribeExport, request);
  }
 
  template <typename DescribeExportRequestT = Model::DescribeExportRequest>
  void DescribeExportAsync(const DescribeExportRequestT& request, const DescribeExportResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DescribeExport, request, handler, context);
  }
 
  virtual Model::DescribeImportOutcome DescribeImport(const Model::DescribeImportRequest& request) const;
 
  template <typename DescribeImportRequestT = Model::DescribeImportRequest>
  Model::DescribeImportOutcomeCallable DescribeImportCallable(const DescribeImportRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DescribeImport, request);
  }
 
  template <typename DescribeImportRequestT = Model::DescribeImportRequest>
  void DescribeImportAsync(const DescribeImportRequestT& request, const DescribeImportResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DescribeImport, request, handler, context);
  }
 
  virtual Model::DescribeIntentOutcome DescribeIntent(const Model::DescribeIntentRequest& request) const;
 
  template <typename DescribeIntentRequestT = Model::DescribeIntentRequest>
  Model::DescribeIntentOutcomeCallable DescribeIntentCallable(const DescribeIntentRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DescribeIntent, request);
  }
 
  template <typename DescribeIntentRequestT = Model::DescribeIntentRequest>
  void DescribeIntentAsync(const DescribeIntentRequestT& request, const DescribeIntentResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DescribeIntent, request, handler, context);
  }
 
  virtual Model::DescribeResourcePolicyOutcome DescribeResourcePolicy(const Model::DescribeResourcePolicyRequest& request) const;
 
  template <typename DescribeResourcePolicyRequestT = Model::DescribeResourcePolicyRequest>
  Model::DescribeResourcePolicyOutcomeCallable DescribeResourcePolicyCallable(const DescribeResourcePolicyRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DescribeResourcePolicy, request);
  }
 
  template <typename DescribeResourcePolicyRequestT = Model::DescribeResourcePolicyRequest>
  void DescribeResourcePolicyAsync(const DescribeResourcePolicyRequestT& request,
                                   const DescribeResourcePolicyResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DescribeResourcePolicy, request, handler, context);
  }
 
  virtual Model::DescribeSlotOutcome DescribeSlot(const Model::DescribeSlotRequest& request) const;
 
  template <typename DescribeSlotRequestT = Model::DescribeSlotRequest>
  Model::DescribeSlotOutcomeCallable DescribeSlotCallable(const DescribeSlotRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DescribeSlot, request);
  }
 
  template <typename DescribeSlotRequestT = Model::DescribeSlotRequest>
  void DescribeSlotAsync(const DescribeSlotRequestT& request, const DescribeSlotResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DescribeSlot, request, handler, context);
  }
 
  virtual Model::DescribeSlotTypeOutcome DescribeSlotType(const Model::DescribeSlotTypeRequest& request) const;
 
  template <typename DescribeSlotTypeRequestT = Model::DescribeSlotTypeRequest>
  Model::DescribeSlotTypeOutcomeCallable DescribeSlotTypeCallable(const DescribeSlotTypeRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DescribeSlotType, request);
  }
 
  template <typename DescribeSlotTypeRequestT = Model::DescribeSlotTypeRequest>
  void DescribeSlotTypeAsync(const DescribeSlotTypeRequestT& request, const DescribeSlotTypeResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DescribeSlotType, request, handler, context);
  }
 
  virtual Model::DescribeTestExecutionOutcome DescribeTestExecution(const Model::DescribeTestExecutionRequest& request) const;
 
  template <typename DescribeTestExecutionRequestT = Model::DescribeTestExecutionRequest>
  Model::DescribeTestExecutionOutcomeCallable DescribeTestExecutionCallable(const DescribeTestExecutionRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DescribeTestExecution, request);
  }
 
  template <typename DescribeTestExecutionRequestT = Model::DescribeTestExecutionRequest>
  void DescribeTestExecutionAsync(const DescribeTestExecutionRequestT& request, const DescribeTestExecutionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DescribeTestExecution, request, handler, context);
  }
 
  virtual Model::DescribeTestSetOutcome DescribeTestSet(const Model::DescribeTestSetRequest& request) const;
 
  template <typename DescribeTestSetRequestT = Model::DescribeTestSetRequest>
  Model::DescribeTestSetOutcomeCallable DescribeTestSetCallable(const DescribeTestSetRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DescribeTestSet, request);
  }
 
  template <typename DescribeTestSetRequestT = Model::DescribeTestSetRequest>
  void DescribeTestSetAsync(const DescribeTestSetRequestT& request, const DescribeTestSetResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DescribeTestSet, request, handler, context);
  }
 
  virtual Model::DescribeTestSetDiscrepancyReportOutcome DescribeTestSetDiscrepancyReport(
      const Model::DescribeTestSetDiscrepancyReportRequest& request) const;
 
  template <typename DescribeTestSetDiscrepancyReportRequestT = Model::DescribeTestSetDiscrepancyReportRequest>
  Model::DescribeTestSetDiscrepancyReportOutcomeCallable DescribeTestSetDiscrepancyReportCallable(
      const DescribeTestSetDiscrepancyReportRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DescribeTestSetDiscrepancyReport, request);
  }
 
  template <typename DescribeTestSetDiscrepancyReportRequestT = Model::DescribeTestSetDiscrepancyReportRequest>
  void DescribeTestSetDiscrepancyReportAsync(const DescribeTestSetDiscrepancyReportRequestT& request,
                                             const DescribeTestSetDiscrepancyReportResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DescribeTestSetDiscrepancyReport, request, handler, context);
  }
 
  virtual Model::DescribeTestSetGenerationOutcome DescribeTestSetGeneration(const Model::DescribeTestSetGenerationRequest& request) const;
 
  template <typename DescribeTestSetGenerationRequestT = Model::DescribeTestSetGenerationRequest>
  Model::DescribeTestSetGenerationOutcomeCallable DescribeTestSetGenerationCallable(
      const DescribeTestSetGenerationRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::DescribeTestSetGeneration, request);
  }
 
  template <typename DescribeTestSetGenerationRequestT = Model::DescribeTestSetGenerationRequest>
  void DescribeTestSetGenerationAsync(const DescribeTestSetGenerationRequestT& request,
                                      const DescribeTestSetGenerationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::DescribeTestSetGeneration, request, handler, context);
  }
 
  virtual Model::GenerateBotElementOutcome GenerateBotElement(const Model::GenerateBotElementRequest& request) const;
 
  template <typename GenerateBotElementRequestT = Model::GenerateBotElementRequest>
  Model::GenerateBotElementOutcomeCallable GenerateBotElementCallable(const GenerateBotElementRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::GenerateBotElement, request);
  }
 
  template <typename GenerateBotElementRequestT = Model::GenerateBotElementRequest>
  void GenerateBotElementAsync(const GenerateBotElementRequestT& request, const GenerateBotElementResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::GenerateBotElement, request, handler, context);
  }
 
  virtual Model::GetTestExecutionArtifactsUrlOutcome GetTestExecutionArtifactsUrl(
      const Model::GetTestExecutionArtifactsUrlRequest& request) const;
 
  template <typename GetTestExecutionArtifactsUrlRequestT = Model::GetTestExecutionArtifactsUrlRequest>
  Model::GetTestExecutionArtifactsUrlOutcomeCallable GetTestExecutionArtifactsUrlCallable(
      const GetTestExecutionArtifactsUrlRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::GetTestExecutionArtifactsUrl, request);
  }
 
  template <typename GetTestExecutionArtifactsUrlRequestT = Model::GetTestExecutionArtifactsUrlRequest>
  void GetTestExecutionArtifactsUrlAsync(const GetTestExecutionArtifactsUrlRequestT& request,
                                         const GetTestExecutionArtifactsUrlResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::GetTestExecutionArtifactsUrl, request, handler, context);
  }
 
  virtual Model::ListAggregatedUtterancesOutcome ListAggregatedUtterances(const Model::ListAggregatedUtterancesRequest& request) const;
 
  template <typename ListAggregatedUtterancesRequestT = Model::ListAggregatedUtterancesRequest>
  Model::ListAggregatedUtterancesOutcomeCallable ListAggregatedUtterancesCallable(const ListAggregatedUtterancesRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListAggregatedUtterances, request);
  }
 
  template <typename ListAggregatedUtterancesRequestT = Model::ListAggregatedUtterancesRequest>
  void ListAggregatedUtterancesAsync(const ListAggregatedUtterancesRequestT& request,
                                     const ListAggregatedUtterancesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListAggregatedUtterances, request, handler, context);
  }
 
  virtual Model::ListBotAliasReplicasOutcome ListBotAliasReplicas(const Model::ListBotAliasReplicasRequest& request) const;
 
  template <typename ListBotAliasReplicasRequestT = Model::ListBotAliasReplicasRequest>
  Model::ListBotAliasReplicasOutcomeCallable ListBotAliasReplicasCallable(const ListBotAliasReplicasRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListBotAliasReplicas, request);
  }
 
  template <typename ListBotAliasReplicasRequestT = Model::ListBotAliasReplicasRequest>
  void ListBotAliasReplicasAsync(const ListBotAliasReplicasRequestT& request, const ListBotAliasReplicasResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListBotAliasReplicas, request, handler, context);
  }
 
  virtual Model::ListBotAliasesOutcome ListBotAliases(const Model::ListBotAliasesRequest& request) const;
 
  template <typename ListBotAliasesRequestT = Model::ListBotAliasesRequest>
  Model::ListBotAliasesOutcomeCallable ListBotAliasesCallable(const ListBotAliasesRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListBotAliases, request);
  }
 
  template <typename ListBotAliasesRequestT = Model::ListBotAliasesRequest>
  void ListBotAliasesAsync(const ListBotAliasesRequestT& request, const ListBotAliasesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListBotAliases, request, handler, context);
  }
 
  virtual Model::ListBotLocalesOutcome ListBotLocales(const Model::ListBotLocalesRequest& request) const;
 
  template <typename ListBotLocalesRequestT = Model::ListBotLocalesRequest>
  Model::ListBotLocalesOutcomeCallable ListBotLocalesCallable(const ListBotLocalesRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListBotLocales, request);
  }
 
  template <typename ListBotLocalesRequestT = Model::ListBotLocalesRequest>
  void ListBotLocalesAsync(const ListBotLocalesRequestT& request, const ListBotLocalesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListBotLocales, request, handler, context);
  }
 
  virtual Model::ListBotRecommendationsOutcome ListBotRecommendations(const Model::ListBotRecommendationsRequest& request) const;
 
  template <typename ListBotRecommendationsRequestT = Model::ListBotRecommendationsRequest>
  Model::ListBotRecommendationsOutcomeCallable ListBotRecommendationsCallable(const ListBotRecommendationsRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListBotRecommendations, request);
  }
 
  template <typename ListBotRecommendationsRequestT = Model::ListBotRecommendationsRequest>
  void ListBotRecommendationsAsync(const ListBotRecommendationsRequestT& request,
                                   const ListBotRecommendationsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListBotRecommendations, request, handler, context);
  }
 
  virtual Model::ListBotReplicasOutcome ListBotReplicas(const Model::ListBotReplicasRequest& request) const;
 
  template <typename ListBotReplicasRequestT = Model::ListBotReplicasRequest>
  Model::ListBotReplicasOutcomeCallable ListBotReplicasCallable(const ListBotReplicasRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListBotReplicas, request);
  }
 
  template <typename ListBotReplicasRequestT = Model::ListBotReplicasRequest>
  void ListBotReplicasAsync(const ListBotReplicasRequestT& request, const ListBotReplicasResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListBotReplicas, request, handler, context);
  }
 
  virtual Model::ListBotResourceGenerationsOutcome ListBotResourceGenerations(
      const Model::ListBotResourceGenerationsRequest& request) const;
 
  template <typename ListBotResourceGenerationsRequestT = Model::ListBotResourceGenerationsRequest>
  Model::ListBotResourceGenerationsOutcomeCallable ListBotResourceGenerationsCallable(
      const ListBotResourceGenerationsRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListBotResourceGenerations, request);
  }
 
  template <typename ListBotResourceGenerationsRequestT = Model::ListBotResourceGenerationsRequest>
  void ListBotResourceGenerationsAsync(const ListBotResourceGenerationsRequestT& request,
                                       const ListBotResourceGenerationsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListBotResourceGenerations, request, handler, context);
  }
 
  virtual Model::ListBotVersionReplicasOutcome ListBotVersionReplicas(const Model::ListBotVersionReplicasRequest& request) const;
 
  template <typename ListBotVersionReplicasRequestT = Model::ListBotVersionReplicasRequest>
  Model::ListBotVersionReplicasOutcomeCallable ListBotVersionReplicasCallable(const ListBotVersionReplicasRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListBotVersionReplicas, request);
  }
 
  template <typename ListBotVersionReplicasRequestT = Model::ListBotVersionReplicasRequest>
  void ListBotVersionReplicasAsync(const ListBotVersionReplicasRequestT& request,
                                   const ListBotVersionReplicasResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListBotVersionReplicas, request, handler, context);
  }
 
  virtual Model::ListBotVersionsOutcome ListBotVersions(const Model::ListBotVersionsRequest& request) const;
 
  template <typename ListBotVersionsRequestT = Model::ListBotVersionsRequest>
  Model::ListBotVersionsOutcomeCallable ListBotVersionsCallable(const ListBotVersionsRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListBotVersions, request);
  }
 
  template <typename ListBotVersionsRequestT = Model::ListBotVersionsRequest>
  void ListBotVersionsAsync(const ListBotVersionsRequestT& request, const ListBotVersionsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListBotVersions, request, handler, context);
  }
 
  virtual Model::ListBotsOutcome ListBots(const Model::ListBotsRequest& request = {}) const;
 
  template <typename ListBotsRequestT = Model::ListBotsRequest>
  Model::ListBotsOutcomeCallable ListBotsCallable(const ListBotsRequestT& request = {}) const {
    return SubmitCallable(&LexModelsV2Client::ListBots, request);
  }
 
  template <typename ListBotsRequestT = Model::ListBotsRequest>
  void ListBotsAsync(const ListBotsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                     const ListBotsRequestT& request = {}) const {
    return SubmitAsync(&LexModelsV2Client::ListBots, request, handler, context);
  }
 
  virtual Model::ListBuiltInIntentsOutcome ListBuiltInIntents(const Model::ListBuiltInIntentsRequest& request) const;
 
  template <typename ListBuiltInIntentsRequestT = Model::ListBuiltInIntentsRequest>
  Model::ListBuiltInIntentsOutcomeCallable ListBuiltInIntentsCallable(const ListBuiltInIntentsRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListBuiltInIntents, request);
  }
 
  template <typename ListBuiltInIntentsRequestT = Model::ListBuiltInIntentsRequest>
  void ListBuiltInIntentsAsync(const ListBuiltInIntentsRequestT& request, const ListBuiltInIntentsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListBuiltInIntents, request, handler, context);
  }
 
  virtual Model::ListBuiltInSlotTypesOutcome ListBuiltInSlotTypes(const Model::ListBuiltInSlotTypesRequest& request) const;
 
  template <typename ListBuiltInSlotTypesRequestT = Model::ListBuiltInSlotTypesRequest>
  Model::ListBuiltInSlotTypesOutcomeCallable ListBuiltInSlotTypesCallable(const ListBuiltInSlotTypesRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListBuiltInSlotTypes, request);
  }
 
  template <typename ListBuiltInSlotTypesRequestT = Model::ListBuiltInSlotTypesRequest>
  void ListBuiltInSlotTypesAsync(const ListBuiltInSlotTypesRequestT& request, const ListBuiltInSlotTypesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListBuiltInSlotTypes, request, handler, context);
  }
 
  virtual Model::ListCustomVocabularyItemsOutcome ListCustomVocabularyItems(const Model::ListCustomVocabularyItemsRequest& request) const;
 
  template <typename ListCustomVocabularyItemsRequestT = Model::ListCustomVocabularyItemsRequest>
  Model::ListCustomVocabularyItemsOutcomeCallable ListCustomVocabularyItemsCallable(
      const ListCustomVocabularyItemsRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListCustomVocabularyItems, request);
  }
 
  template <typename ListCustomVocabularyItemsRequestT = Model::ListCustomVocabularyItemsRequest>
  void ListCustomVocabularyItemsAsync(const ListCustomVocabularyItemsRequestT& request,
                                      const ListCustomVocabularyItemsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListCustomVocabularyItems, request, handler, context);
  }
 
  virtual Model::ListExportsOutcome ListExports(const Model::ListExportsRequest& request = {}) const;
 
  template <typename ListExportsRequestT = Model::ListExportsRequest>
  Model::ListExportsOutcomeCallable ListExportsCallable(const ListExportsRequestT& request = {}) const {
    return SubmitCallable(&LexModelsV2Client::ListExports, request);
  }
 
  template <typename ListExportsRequestT = Model::ListExportsRequest>
  void ListExportsAsync(const ListExportsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListExportsRequestT& request = {}) const {
    return SubmitAsync(&LexModelsV2Client::ListExports, request, handler, context);
  }
 
  virtual Model::ListImportsOutcome ListImports(const Model::ListImportsRequest& request = {}) const;
 
  template <typename ListImportsRequestT = Model::ListImportsRequest>
  Model::ListImportsOutcomeCallable ListImportsCallable(const ListImportsRequestT& request = {}) const {
    return SubmitCallable(&LexModelsV2Client::ListImports, request);
  }
 
  template <typename ListImportsRequestT = Model::ListImportsRequest>
  void ListImportsAsync(const ListImportsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListImportsRequestT& request = {}) const {
    return SubmitAsync(&LexModelsV2Client::ListImports, request, handler, context);
  }
 
  virtual Model::ListIntentMetricsOutcome ListIntentMetrics(const Model::ListIntentMetricsRequest& request) const;
 
  template <typename ListIntentMetricsRequestT = Model::ListIntentMetricsRequest>
  Model::ListIntentMetricsOutcomeCallable ListIntentMetricsCallable(const ListIntentMetricsRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListIntentMetrics, request);
  }
 
  template <typename ListIntentMetricsRequestT = Model::ListIntentMetricsRequest>
  void ListIntentMetricsAsync(const ListIntentMetricsRequestT& request, const ListIntentMetricsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListIntentMetrics, request, handler, context);
  }
 
  virtual Model::ListIntentPathsOutcome ListIntentPaths(const Model::ListIntentPathsRequest& request) const;
 
  template <typename ListIntentPathsRequestT = Model::ListIntentPathsRequest>
  Model::ListIntentPathsOutcomeCallable ListIntentPathsCallable(const ListIntentPathsRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListIntentPaths, request);
  }
 
  template <typename ListIntentPathsRequestT = Model::ListIntentPathsRequest>
  void ListIntentPathsAsync(const ListIntentPathsRequestT& request, const ListIntentPathsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListIntentPaths, request, handler, context);
  }
 
  virtual Model::ListIntentStageMetricsOutcome ListIntentStageMetrics(const Model::ListIntentStageMetricsRequest& request) const;
 
  template <typename ListIntentStageMetricsRequestT = Model::ListIntentStageMetricsRequest>
  Model::ListIntentStageMetricsOutcomeCallable ListIntentStageMetricsCallable(const ListIntentStageMetricsRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListIntentStageMetrics, request);
  }
 
  template <typename ListIntentStageMetricsRequestT = Model::ListIntentStageMetricsRequest>
  void ListIntentStageMetricsAsync(const ListIntentStageMetricsRequestT& request,
                                   const ListIntentStageMetricsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListIntentStageMetrics, request, handler, context);
  }
 
  virtual Model::ListIntentsOutcome ListIntents(const Model::ListIntentsRequest& request) const;
 
  template <typename ListIntentsRequestT = Model::ListIntentsRequest>
  Model::ListIntentsOutcomeCallable ListIntentsCallable(const ListIntentsRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListIntents, request);
  }
 
  template <typename ListIntentsRequestT = Model::ListIntentsRequest>
  void ListIntentsAsync(const ListIntentsRequestT& request, const ListIntentsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListIntents, request, handler, context);
  }
 
  virtual Model::ListRecommendedIntentsOutcome ListRecommendedIntents(const Model::ListRecommendedIntentsRequest& request) const;
 
  template <typename ListRecommendedIntentsRequestT = Model::ListRecommendedIntentsRequest>
  Model::ListRecommendedIntentsOutcomeCallable ListRecommendedIntentsCallable(const ListRecommendedIntentsRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListRecommendedIntents, request);
  }
 
  template <typename ListRecommendedIntentsRequestT = Model::ListRecommendedIntentsRequest>
  void ListRecommendedIntentsAsync(const ListRecommendedIntentsRequestT& request,
                                   const ListRecommendedIntentsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListRecommendedIntents, request, handler, context);
  }
 
  virtual Model::ListSessionAnalyticsDataOutcome ListSessionAnalyticsData(const Model::ListSessionAnalyticsDataRequest& request) const;
 
  template <typename ListSessionAnalyticsDataRequestT = Model::ListSessionAnalyticsDataRequest>
  Model::ListSessionAnalyticsDataOutcomeCallable ListSessionAnalyticsDataCallable(const ListSessionAnalyticsDataRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListSessionAnalyticsData, request);
  }
 
  template <typename ListSessionAnalyticsDataRequestT = Model::ListSessionAnalyticsDataRequest>
  void ListSessionAnalyticsDataAsync(const ListSessionAnalyticsDataRequestT& request,
                                     const ListSessionAnalyticsDataResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListSessionAnalyticsData, request, handler, context);
  }
 
  virtual Model::ListSessionMetricsOutcome ListSessionMetrics(const Model::ListSessionMetricsRequest& request) const;
 
  template <typename ListSessionMetricsRequestT = Model::ListSessionMetricsRequest>
  Model::ListSessionMetricsOutcomeCallable ListSessionMetricsCallable(const ListSessionMetricsRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListSessionMetrics, request);
  }
 
  template <typename ListSessionMetricsRequestT = Model::ListSessionMetricsRequest>
  void ListSessionMetricsAsync(const ListSessionMetricsRequestT& request, const ListSessionMetricsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListSessionMetrics, request, handler, context);
  }
 
  virtual Model::ListSlotTypesOutcome ListSlotTypes(const Model::ListSlotTypesRequest& request) const;
 
  template <typename ListSlotTypesRequestT = Model::ListSlotTypesRequest>
  Model::ListSlotTypesOutcomeCallable ListSlotTypesCallable(const ListSlotTypesRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListSlotTypes, request);
  }
 
  template <typename ListSlotTypesRequestT = Model::ListSlotTypesRequest>
  void ListSlotTypesAsync(const ListSlotTypesRequestT& request, const ListSlotTypesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListSlotTypes, request, handler, context);
  }
 
  virtual Model::ListSlotsOutcome ListSlots(const Model::ListSlotsRequest& request) const;
 
  template <typename ListSlotsRequestT = Model::ListSlotsRequest>
  Model::ListSlotsOutcomeCallable ListSlotsCallable(const ListSlotsRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListSlots, request);
  }
 
  template <typename ListSlotsRequestT = Model::ListSlotsRequest>
  void ListSlotsAsync(const ListSlotsRequestT& request, const ListSlotsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListSlots, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTestExecutionResultItemsOutcome ListTestExecutionResultItems(
      const Model::ListTestExecutionResultItemsRequest& request) const;
 
  template <typename ListTestExecutionResultItemsRequestT = Model::ListTestExecutionResultItemsRequest>
  Model::ListTestExecutionResultItemsOutcomeCallable ListTestExecutionResultItemsCallable(
      const ListTestExecutionResultItemsRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListTestExecutionResultItems, request);
  }
 
  template <typename ListTestExecutionResultItemsRequestT = Model::ListTestExecutionResultItemsRequest>
  void ListTestExecutionResultItemsAsync(const ListTestExecutionResultItemsRequestT& request,
                                         const ListTestExecutionResultItemsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListTestExecutionResultItems, request, handler, context);
  }
 
  virtual Model::ListTestExecutionsOutcome ListTestExecutions(const Model::ListTestExecutionsRequest& request = {}) const;
 
  template <typename ListTestExecutionsRequestT = Model::ListTestExecutionsRequest>
  Model::ListTestExecutionsOutcomeCallable ListTestExecutionsCallable(const ListTestExecutionsRequestT& request = {}) const {
    return SubmitCallable(&LexModelsV2Client::ListTestExecutions, request);
  }
 
  template <typename ListTestExecutionsRequestT = Model::ListTestExecutionsRequest>
  void ListTestExecutionsAsync(const ListTestExecutionsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListTestExecutionsRequestT& request = {}) const {
    return SubmitAsync(&LexModelsV2Client::ListTestExecutions, request, handler, context);
  }
 
  virtual Model::ListTestSetRecordsOutcome ListTestSetRecords(const Model::ListTestSetRecordsRequest& request) const;
 
  template <typename ListTestSetRecordsRequestT = Model::ListTestSetRecordsRequest>
  Model::ListTestSetRecordsOutcomeCallable ListTestSetRecordsCallable(const ListTestSetRecordsRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListTestSetRecords, request);
  }
 
  template <typename ListTestSetRecordsRequestT = Model::ListTestSetRecordsRequest>
  void ListTestSetRecordsAsync(const ListTestSetRecordsRequestT& request, const ListTestSetRecordsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListTestSetRecords, request, handler, context);
  }
 
  virtual Model::ListTestSetsOutcome ListTestSets(const Model::ListTestSetsRequest& request = {}) const;
 
  template <typename ListTestSetsRequestT = Model::ListTestSetsRequest>
  Model::ListTestSetsOutcomeCallable ListTestSetsCallable(const ListTestSetsRequestT& request = {}) const {
    return SubmitCallable(&LexModelsV2Client::ListTestSets, request);
  }
 
  template <typename ListTestSetsRequestT = Model::ListTestSetsRequest>
  void ListTestSetsAsync(const ListTestSetsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListTestSetsRequestT& request = {}) const {
    return SubmitAsync(&LexModelsV2Client::ListTestSets, request, handler, context);
  }
 
  virtual Model::ListUtteranceAnalyticsDataOutcome ListUtteranceAnalyticsData(
      const Model::ListUtteranceAnalyticsDataRequest& request) const;
 
  template <typename ListUtteranceAnalyticsDataRequestT = Model::ListUtteranceAnalyticsDataRequest>
  Model::ListUtteranceAnalyticsDataOutcomeCallable ListUtteranceAnalyticsDataCallable(
      const ListUtteranceAnalyticsDataRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListUtteranceAnalyticsData, request);
  }
 
  template <typename ListUtteranceAnalyticsDataRequestT = Model::ListUtteranceAnalyticsDataRequest>
  void ListUtteranceAnalyticsDataAsync(const ListUtteranceAnalyticsDataRequestT& request,
                                       const ListUtteranceAnalyticsDataResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListUtteranceAnalyticsData, request, handler, context);
  }
 
  virtual Model::ListUtteranceMetricsOutcome ListUtteranceMetrics(const Model::ListUtteranceMetricsRequest& request) const;
 
  template <typename ListUtteranceMetricsRequestT = Model::ListUtteranceMetricsRequest>
  Model::ListUtteranceMetricsOutcomeCallable ListUtteranceMetricsCallable(const ListUtteranceMetricsRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::ListUtteranceMetrics, request);
  }
 
  template <typename ListUtteranceMetricsRequestT = Model::ListUtteranceMetricsRequest>
  void ListUtteranceMetricsAsync(const ListUtteranceMetricsRequestT& request, const ListUtteranceMetricsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::ListUtteranceMetrics, request, handler, context);
  }
 
  virtual Model::SearchAssociatedTranscriptsOutcome SearchAssociatedTranscripts(
      const Model::SearchAssociatedTranscriptsRequest& request) const;
 
  template <typename SearchAssociatedTranscriptsRequestT = Model::SearchAssociatedTranscriptsRequest>
  Model::SearchAssociatedTranscriptsOutcomeCallable SearchAssociatedTranscriptsCallable(
      const SearchAssociatedTranscriptsRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::SearchAssociatedTranscripts, request);
  }
 
  template <typename SearchAssociatedTranscriptsRequestT = Model::SearchAssociatedTranscriptsRequest>
  void SearchAssociatedTranscriptsAsync(const SearchAssociatedTranscriptsRequestT& request,
                                        const SearchAssociatedTranscriptsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::SearchAssociatedTranscripts, request, handler, context);
  }
 
  virtual Model::StartBotRecommendationOutcome StartBotRecommendation(const Model::StartBotRecommendationRequest& request) const;
 
  template <typename StartBotRecommendationRequestT = Model::StartBotRecommendationRequest>
  Model::StartBotRecommendationOutcomeCallable StartBotRecommendationCallable(const StartBotRecommendationRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::StartBotRecommendation, request);
  }
 
  template <typename StartBotRecommendationRequestT = Model::StartBotRecommendationRequest>
  void StartBotRecommendationAsync(const StartBotRecommendationRequestT& request,
                                   const StartBotRecommendationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::StartBotRecommendation, request, handler, context);
  }
 
  virtual Model::StartBotResourceGenerationOutcome StartBotResourceGeneration(
      const Model::StartBotResourceGenerationRequest& request) const;
 
  template <typename StartBotResourceGenerationRequestT = Model::StartBotResourceGenerationRequest>
  Model::StartBotResourceGenerationOutcomeCallable StartBotResourceGenerationCallable(
      const StartBotResourceGenerationRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::StartBotResourceGeneration, request);
  }
 
  template <typename StartBotResourceGenerationRequestT = Model::StartBotResourceGenerationRequest>
  void StartBotResourceGenerationAsync(const StartBotResourceGenerationRequestT& request,
                                       const StartBotResourceGenerationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::StartBotResourceGeneration, request, handler, context);
  }
 
  virtual Model::StartImportOutcome StartImport(const Model::StartImportRequest& request) const;
 
  template <typename StartImportRequestT = Model::StartImportRequest>
  Model::StartImportOutcomeCallable StartImportCallable(const StartImportRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::StartImport, request);
  }
 
  template <typename StartImportRequestT = Model::StartImportRequest>
  void StartImportAsync(const StartImportRequestT& request, const StartImportResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::StartImport, request, handler, context);
  }
 
  virtual Model::StartTestExecutionOutcome StartTestExecution(const Model::StartTestExecutionRequest& request) const;
 
  template <typename StartTestExecutionRequestT = Model::StartTestExecutionRequest>
  Model::StartTestExecutionOutcomeCallable StartTestExecutionCallable(const StartTestExecutionRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::StartTestExecution, request);
  }
 
  template <typename StartTestExecutionRequestT = Model::StartTestExecutionRequest>
  void StartTestExecutionAsync(const StartTestExecutionRequestT& request, const StartTestExecutionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::StartTestExecution, request, handler, context);
  }
 
  virtual Model::StartTestSetGenerationOutcome StartTestSetGeneration(const Model::StartTestSetGenerationRequest& request) const;
 
  template <typename StartTestSetGenerationRequestT = Model::StartTestSetGenerationRequest>
  Model::StartTestSetGenerationOutcomeCallable StartTestSetGenerationCallable(const StartTestSetGenerationRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::StartTestSetGeneration, request);
  }
 
  template <typename StartTestSetGenerationRequestT = Model::StartTestSetGenerationRequest>
  void StartTestSetGenerationAsync(const StartTestSetGenerationRequestT& request,
                                   const StartTestSetGenerationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::StartTestSetGeneration, request, handler, context);
  }
 
  virtual Model::StopBotRecommendationOutcome StopBotRecommendation(const Model::StopBotRecommendationRequest& request) const;
 
  template <typename StopBotRecommendationRequestT = Model::StopBotRecommendationRequest>
  Model::StopBotRecommendationOutcomeCallable StopBotRecommendationCallable(const StopBotRecommendationRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::StopBotRecommendation, request);
  }
 
  template <typename StopBotRecommendationRequestT = Model::StopBotRecommendationRequest>
  void StopBotRecommendationAsync(const StopBotRecommendationRequestT& request, const StopBotRecommendationResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::StopBotRecommendation, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateBotOutcome UpdateBot(const Model::UpdateBotRequest& request) const;
 
  template <typename UpdateBotRequestT = Model::UpdateBotRequest>
  Model::UpdateBotOutcomeCallable UpdateBotCallable(const UpdateBotRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::UpdateBot, request);
  }
 
  template <typename UpdateBotRequestT = Model::UpdateBotRequest>
  void UpdateBotAsync(const UpdateBotRequestT& request, const UpdateBotResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::UpdateBot, request, handler, context);
  }
 
  virtual Model::UpdateBotAliasOutcome UpdateBotAlias(const Model::UpdateBotAliasRequest& request) const;
 
  template <typename UpdateBotAliasRequestT = Model::UpdateBotAliasRequest>
  Model::UpdateBotAliasOutcomeCallable UpdateBotAliasCallable(const UpdateBotAliasRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::UpdateBotAlias, request);
  }
 
  template <typename UpdateBotAliasRequestT = Model::UpdateBotAliasRequest>
  void UpdateBotAliasAsync(const UpdateBotAliasRequestT& request, const UpdateBotAliasResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::UpdateBotAlias, request, handler, context);
  }
 
  virtual Model::UpdateBotLocaleOutcome UpdateBotLocale(const Model::UpdateBotLocaleRequest& request) const;
 
  template <typename UpdateBotLocaleRequestT = Model::UpdateBotLocaleRequest>
  Model::UpdateBotLocaleOutcomeCallable UpdateBotLocaleCallable(const UpdateBotLocaleRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::UpdateBotLocale, request);
  }
 
  template <typename UpdateBotLocaleRequestT = Model::UpdateBotLocaleRequest>
  void UpdateBotLocaleAsync(const UpdateBotLocaleRequestT& request, const UpdateBotLocaleResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::UpdateBotLocale, request, handler, context);
  }
 
  virtual Model::UpdateBotRecommendationOutcome UpdateBotRecommendation(const Model::UpdateBotRecommendationRequest& request) const;
 
  template <typename UpdateBotRecommendationRequestT = Model::UpdateBotRecommendationRequest>
  Model::UpdateBotRecommendationOutcomeCallable UpdateBotRecommendationCallable(const UpdateBotRecommendationRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::UpdateBotRecommendation, request);
  }
 
  template <typename UpdateBotRecommendationRequestT = Model::UpdateBotRecommendationRequest>
  void UpdateBotRecommendationAsync(const UpdateBotRecommendationRequestT& request,
                                    const UpdateBotRecommendationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::UpdateBotRecommendation, request, handler, context);
  }
 
  virtual Model::UpdateExportOutcome UpdateExport(const Model::UpdateExportRequest& request) const;
 
  template <typename UpdateExportRequestT = Model::UpdateExportRequest>
  Model::UpdateExportOutcomeCallable UpdateExportCallable(const UpdateExportRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::UpdateExport, request);
  }
 
  template <typename UpdateExportRequestT = Model::UpdateExportRequest>
  void UpdateExportAsync(const UpdateExportRequestT& request, const UpdateExportResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::UpdateExport, request, handler, context);
  }
 
  virtual Model::UpdateIntentOutcome UpdateIntent(const Model::UpdateIntentRequest& request) const;
 
  template <typename UpdateIntentRequestT = Model::UpdateIntentRequest>
  Model::UpdateIntentOutcomeCallable UpdateIntentCallable(const UpdateIntentRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::UpdateIntent, request);
  }
 
  template <typename UpdateIntentRequestT = Model::UpdateIntentRequest>
  void UpdateIntentAsync(const UpdateIntentRequestT& request, const UpdateIntentResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::UpdateIntent, request, handler, context);
  }
 
  virtual Model::UpdateResourcePolicyOutcome UpdateResourcePolicy(const Model::UpdateResourcePolicyRequest& request) const;
 
  template <typename UpdateResourcePolicyRequestT = Model::UpdateResourcePolicyRequest>
  Model::UpdateResourcePolicyOutcomeCallable UpdateResourcePolicyCallable(const UpdateResourcePolicyRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::UpdateResourcePolicy, request);
  }
 
  template <typename UpdateResourcePolicyRequestT = Model::UpdateResourcePolicyRequest>
  void UpdateResourcePolicyAsync(const UpdateResourcePolicyRequestT& request, const UpdateResourcePolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::UpdateResourcePolicy, request, handler, context);
  }
 
  virtual Model::UpdateSlotOutcome UpdateSlot(const Model::UpdateSlotRequest& request) const;
 
  template <typename UpdateSlotRequestT = Model::UpdateSlotRequest>
  Model::UpdateSlotOutcomeCallable UpdateSlotCallable(const UpdateSlotRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::UpdateSlot, request);
  }
 
  template <typename UpdateSlotRequestT = Model::UpdateSlotRequest>
  void UpdateSlotAsync(const UpdateSlotRequestT& request, const UpdateSlotResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::UpdateSlot, request, handler, context);
  }
 
  virtual Model::UpdateSlotTypeOutcome UpdateSlotType(const Model::UpdateSlotTypeRequest& request) const;
 
  template <typename UpdateSlotTypeRequestT = Model::UpdateSlotTypeRequest>
  Model::UpdateSlotTypeOutcomeCallable UpdateSlotTypeCallable(const UpdateSlotTypeRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::UpdateSlotType, request);
  }
 
  template <typename UpdateSlotTypeRequestT = Model::UpdateSlotTypeRequest>
  void UpdateSlotTypeAsync(const UpdateSlotTypeRequestT& request, const UpdateSlotTypeResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::UpdateSlotType, request, handler, context);
  }
 
  virtual Model::UpdateTestSetOutcome UpdateTestSet(const Model::UpdateTestSetRequest& request) const;
 
  template <typename UpdateTestSetRequestT = Model::UpdateTestSetRequest>
  Model::UpdateTestSetOutcomeCallable UpdateTestSetCallable(const UpdateTestSetRequestT& request) const {
    return SubmitCallable(&LexModelsV2Client::UpdateTestSet, request);
  }
 
  template <typename UpdateTestSetRequestT = Model::UpdateTestSetRequest>
  void UpdateTestSetAsync(const UpdateTestSetRequestT& request, const UpdateTestSetResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LexModelsV2Client::UpdateTestSet, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<LexModelsV2EndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<LexModelsV2Client>;
  void init(const LexModelsV2ClientConfiguration& clientConfiguration);
 
  LexModelsV2ClientConfiguration m_clientConfiguration;
  std::shared_ptr<LexModelsV2EndpointProviderBase> m_endpointProvider;
};
 
}  // namespace LexModelsV2
}  // namespace Aws