LexModelsV2Client.h

 
#pragma once
#include <aws/lexv2-models/LexModelsV2_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/lexv2-models/LexModelsV2ServiceClientModel.h>
 
namespace Aws
{
namespace LexModelsV2
{
  class AWS_LEXMODELSV2_API LexModelsV2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      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