LexModelBuildingServiceClient.h

 
#pragma once
#include <aws/lex-models/LexModelBuildingService_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/lex-models/LexModelBuildingServiceServiceClientModel.h>
 
namespace Aws
{
namespace LexModelBuildingService
{
  class AWS_LEXMODELBUILDINGSERVICE_API LexModelBuildingServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<LexModelBuildingServiceClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef LexModelBuildingServiceClientConfiguration ClientConfigurationType;
      typedef LexModelBuildingServiceEndpointProvider EndpointProviderType;
 
        LexModelBuildingServiceClient(const Aws::LexModelBuildingService::LexModelBuildingServiceClientConfiguration& clientConfiguration = Aws::LexModelBuildingService::LexModelBuildingServiceClientConfiguration(),
                                      std::shared_ptr<LexModelBuildingServiceEndpointProviderBase> endpointProvider = nullptr);
 
        LexModelBuildingServiceClient(const Aws::Auth::AWSCredentials& credentials,
                                      std::shared_ptr<LexModelBuildingServiceEndpointProviderBase> endpointProvider = nullptr,
                                      const Aws::LexModelBuildingService::LexModelBuildingServiceClientConfiguration& clientConfiguration = Aws::LexModelBuildingService::LexModelBuildingServiceClientConfiguration());
 
        LexModelBuildingServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                      std::shared_ptr<LexModelBuildingServiceEndpointProviderBase> endpointProvider = nullptr,
                                      const Aws::LexModelBuildingService::LexModelBuildingServiceClientConfiguration& clientConfiguration = Aws::LexModelBuildingService::LexModelBuildingServiceClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        LexModelBuildingServiceClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        LexModelBuildingServiceClient(const Aws::Auth::AWSCredentials& credentials,
                                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
        LexModelBuildingServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~LexModelBuildingServiceClient();
 
        virtual Model::CreateBotVersionOutcome CreateBotVersion(const Model::CreateBotVersionRequest& request) const;
 
        template<typename CreateBotVersionRequestT = Model::CreateBotVersionRequest>
        Model::CreateBotVersionOutcomeCallable CreateBotVersionCallable(const CreateBotVersionRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::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(&LexModelBuildingServiceClient::CreateBotVersion, request, handler, context);
        }
 
        virtual Model::CreateIntentVersionOutcome CreateIntentVersion(const Model::CreateIntentVersionRequest& request) const;
 
        template<typename CreateIntentVersionRequestT = Model::CreateIntentVersionRequest>
        Model::CreateIntentVersionOutcomeCallable CreateIntentVersionCallable(const CreateIntentVersionRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::CreateIntentVersion, request);
        }
 
        template<typename CreateIntentVersionRequestT = Model::CreateIntentVersionRequest>
        void CreateIntentVersionAsync(const CreateIntentVersionRequestT& request, const CreateIntentVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::CreateIntentVersion, request, handler, context);
        }
 
        virtual Model::CreateSlotTypeVersionOutcome CreateSlotTypeVersion(const Model::CreateSlotTypeVersionRequest& request) const;
 
        template<typename CreateSlotTypeVersionRequestT = Model::CreateSlotTypeVersionRequest>
        Model::CreateSlotTypeVersionOutcomeCallable CreateSlotTypeVersionCallable(const CreateSlotTypeVersionRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::CreateSlotTypeVersion, request);
        }
 
        template<typename CreateSlotTypeVersionRequestT = Model::CreateSlotTypeVersionRequest>
        void CreateSlotTypeVersionAsync(const CreateSlotTypeVersionRequestT& request, const CreateSlotTypeVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::CreateSlotTypeVersion, 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(&LexModelBuildingServiceClient::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(&LexModelBuildingServiceClient::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(&LexModelBuildingServiceClient::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(&LexModelBuildingServiceClient::DeleteBotAlias, request, handler, context);
        }
 
        virtual Model::DeleteBotChannelAssociationOutcome DeleteBotChannelAssociation(const Model::DeleteBotChannelAssociationRequest& request) const;
 
        template<typename DeleteBotChannelAssociationRequestT = Model::DeleteBotChannelAssociationRequest>
        Model::DeleteBotChannelAssociationOutcomeCallable DeleteBotChannelAssociationCallable(const DeleteBotChannelAssociationRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::DeleteBotChannelAssociation, request);
        }
 
        template<typename DeleteBotChannelAssociationRequestT = Model::DeleteBotChannelAssociationRequest>
        void DeleteBotChannelAssociationAsync(const DeleteBotChannelAssociationRequestT& request, const DeleteBotChannelAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::DeleteBotChannelAssociation, 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(&LexModelBuildingServiceClient::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(&LexModelBuildingServiceClient::DeleteBotVersion, 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(&LexModelBuildingServiceClient::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(&LexModelBuildingServiceClient::DeleteIntent, request, handler, context);
        }
 
        virtual Model::DeleteIntentVersionOutcome DeleteIntentVersion(const Model::DeleteIntentVersionRequest& request) const;
 
        template<typename DeleteIntentVersionRequestT = Model::DeleteIntentVersionRequest>
        Model::DeleteIntentVersionOutcomeCallable DeleteIntentVersionCallable(const DeleteIntentVersionRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::DeleteIntentVersion, request);
        }
 
        template<typename DeleteIntentVersionRequestT = Model::DeleteIntentVersionRequest>
        void DeleteIntentVersionAsync(const DeleteIntentVersionRequestT& request, const DeleteIntentVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::DeleteIntentVersion, 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(&LexModelBuildingServiceClient::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(&LexModelBuildingServiceClient::DeleteSlotType, request, handler, context);
        }
 
        virtual Model::DeleteSlotTypeVersionOutcome DeleteSlotTypeVersion(const Model::DeleteSlotTypeVersionRequest& request) const;
 
        template<typename DeleteSlotTypeVersionRequestT = Model::DeleteSlotTypeVersionRequest>
        Model::DeleteSlotTypeVersionOutcomeCallable DeleteSlotTypeVersionCallable(const DeleteSlotTypeVersionRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::DeleteSlotTypeVersion, request);
        }
 
        template<typename DeleteSlotTypeVersionRequestT = Model::DeleteSlotTypeVersionRequest>
        void DeleteSlotTypeVersionAsync(const DeleteSlotTypeVersionRequestT& request, const DeleteSlotTypeVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::DeleteSlotTypeVersion, 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(&LexModelBuildingServiceClient::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(&LexModelBuildingServiceClient::DeleteUtterances, request, handler, context);
        }
 
        virtual Model::GetBotOutcome GetBot(const Model::GetBotRequest& request) const;
 
        template<typename GetBotRequestT = Model::GetBotRequest>
        Model::GetBotOutcomeCallable GetBotCallable(const GetBotRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetBot, request);
        }
 
        template<typename GetBotRequestT = Model::GetBotRequest>
        void GetBotAsync(const GetBotRequestT& request, const GetBotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetBot, request, handler, context);
        }
 
        virtual Model::GetBotAliasOutcome GetBotAlias(const Model::GetBotAliasRequest& request) const;
 
        template<typename GetBotAliasRequestT = Model::GetBotAliasRequest>
        Model::GetBotAliasOutcomeCallable GetBotAliasCallable(const GetBotAliasRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetBotAlias, request);
        }
 
        template<typename GetBotAliasRequestT = Model::GetBotAliasRequest>
        void GetBotAliasAsync(const GetBotAliasRequestT& request, const GetBotAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetBotAlias, request, handler, context);
        }
 
        virtual Model::GetBotAliasesOutcome GetBotAliases(const Model::GetBotAliasesRequest& request) const;
 
        template<typename GetBotAliasesRequestT = Model::GetBotAliasesRequest>
        Model::GetBotAliasesOutcomeCallable GetBotAliasesCallable(const GetBotAliasesRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetBotAliases, request);
        }
 
        template<typename GetBotAliasesRequestT = Model::GetBotAliasesRequest>
        void GetBotAliasesAsync(const GetBotAliasesRequestT& request, const GetBotAliasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetBotAliases, request, handler, context);
        }
 
        virtual Model::GetBotChannelAssociationOutcome GetBotChannelAssociation(const Model::GetBotChannelAssociationRequest& request) const;
 
        template<typename GetBotChannelAssociationRequestT = Model::GetBotChannelAssociationRequest>
        Model::GetBotChannelAssociationOutcomeCallable GetBotChannelAssociationCallable(const GetBotChannelAssociationRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetBotChannelAssociation, request);
        }
 
        template<typename GetBotChannelAssociationRequestT = Model::GetBotChannelAssociationRequest>
        void GetBotChannelAssociationAsync(const GetBotChannelAssociationRequestT& request, const GetBotChannelAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetBotChannelAssociation, request, handler, context);
        }
 
        virtual Model::GetBotChannelAssociationsOutcome GetBotChannelAssociations(const Model::GetBotChannelAssociationsRequest& request) const;
 
        template<typename GetBotChannelAssociationsRequestT = Model::GetBotChannelAssociationsRequest>
        Model::GetBotChannelAssociationsOutcomeCallable GetBotChannelAssociationsCallable(const GetBotChannelAssociationsRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetBotChannelAssociations, request);
        }
 
        template<typename GetBotChannelAssociationsRequestT = Model::GetBotChannelAssociationsRequest>
        void GetBotChannelAssociationsAsync(const GetBotChannelAssociationsRequestT& request, const GetBotChannelAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetBotChannelAssociations, request, handler, context);
        }
 
        virtual Model::GetBotVersionsOutcome GetBotVersions(const Model::GetBotVersionsRequest& request) const;
 
        template<typename GetBotVersionsRequestT = Model::GetBotVersionsRequest>
        Model::GetBotVersionsOutcomeCallable GetBotVersionsCallable(const GetBotVersionsRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetBotVersions, request);
        }
 
        template<typename GetBotVersionsRequestT = Model::GetBotVersionsRequest>
        void GetBotVersionsAsync(const GetBotVersionsRequestT& request, const GetBotVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetBotVersions, request, handler, context);
        }
 
        virtual Model::GetBotsOutcome GetBots(const Model::GetBotsRequest& request = {}) const;
 
        template<typename GetBotsRequestT = Model::GetBotsRequest>
        Model::GetBotsOutcomeCallable GetBotsCallable(const GetBotsRequestT& request = {}) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetBots, request);
        }
 
        template<typename GetBotsRequestT = Model::GetBotsRequest>
        void GetBotsAsync(const GetBotsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetBotsRequestT& request = {}) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetBots, request, handler, context);
        }
 
        virtual Model::GetBuiltinIntentOutcome GetBuiltinIntent(const Model::GetBuiltinIntentRequest& request) const;
 
        template<typename GetBuiltinIntentRequestT = Model::GetBuiltinIntentRequest>
        Model::GetBuiltinIntentOutcomeCallable GetBuiltinIntentCallable(const GetBuiltinIntentRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetBuiltinIntent, request);
        }
 
        template<typename GetBuiltinIntentRequestT = Model::GetBuiltinIntentRequest>
        void GetBuiltinIntentAsync(const GetBuiltinIntentRequestT& request, const GetBuiltinIntentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetBuiltinIntent, request, handler, context);
        }
 
        virtual Model::GetBuiltinIntentsOutcome GetBuiltinIntents(const Model::GetBuiltinIntentsRequest& request = {}) const;
 
        template<typename GetBuiltinIntentsRequestT = Model::GetBuiltinIntentsRequest>
        Model::GetBuiltinIntentsOutcomeCallable GetBuiltinIntentsCallable(const GetBuiltinIntentsRequestT& request = {}) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetBuiltinIntents, request);
        }
 
        template<typename GetBuiltinIntentsRequestT = Model::GetBuiltinIntentsRequest>
        void GetBuiltinIntentsAsync(const GetBuiltinIntentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetBuiltinIntentsRequestT& request = {}) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetBuiltinIntents, request, handler, context);
        }
 
        virtual Model::GetBuiltinSlotTypesOutcome GetBuiltinSlotTypes(const Model::GetBuiltinSlotTypesRequest& request = {}) const;
 
        template<typename GetBuiltinSlotTypesRequestT = Model::GetBuiltinSlotTypesRequest>
        Model::GetBuiltinSlotTypesOutcomeCallable GetBuiltinSlotTypesCallable(const GetBuiltinSlotTypesRequestT& request = {}) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetBuiltinSlotTypes, request);
        }
 
        template<typename GetBuiltinSlotTypesRequestT = Model::GetBuiltinSlotTypesRequest>
        void GetBuiltinSlotTypesAsync(const GetBuiltinSlotTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetBuiltinSlotTypesRequestT& request = {}) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetBuiltinSlotTypes, request, handler, context);
        }
 
        virtual Model::GetExportOutcome GetExport(const Model::GetExportRequest& request) const;
 
        template<typename GetExportRequestT = Model::GetExportRequest>
        Model::GetExportOutcomeCallable GetExportCallable(const GetExportRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetExport, request);
        }
 
        template<typename GetExportRequestT = Model::GetExportRequest>
        void GetExportAsync(const GetExportRequestT& request, const GetExportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetExport, request, handler, context);
        }
 
        virtual Model::GetImportOutcome GetImport(const Model::GetImportRequest& request) const;
 
        template<typename GetImportRequestT = Model::GetImportRequest>
        Model::GetImportOutcomeCallable GetImportCallable(const GetImportRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetImport, request);
        }
 
        template<typename GetImportRequestT = Model::GetImportRequest>
        void GetImportAsync(const GetImportRequestT& request, const GetImportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetImport, request, handler, context);
        }
 
        virtual Model::GetIntentOutcome GetIntent(const Model::GetIntentRequest& request) const;
 
        template<typename GetIntentRequestT = Model::GetIntentRequest>
        Model::GetIntentOutcomeCallable GetIntentCallable(const GetIntentRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetIntent, request);
        }
 
        template<typename GetIntentRequestT = Model::GetIntentRequest>
        void GetIntentAsync(const GetIntentRequestT& request, const GetIntentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetIntent, request, handler, context);
        }
 
        virtual Model::GetIntentVersionsOutcome GetIntentVersions(const Model::GetIntentVersionsRequest& request) const;
 
        template<typename GetIntentVersionsRequestT = Model::GetIntentVersionsRequest>
        Model::GetIntentVersionsOutcomeCallable GetIntentVersionsCallable(const GetIntentVersionsRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetIntentVersions, request);
        }
 
        template<typename GetIntentVersionsRequestT = Model::GetIntentVersionsRequest>
        void GetIntentVersionsAsync(const GetIntentVersionsRequestT& request, const GetIntentVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetIntentVersions, request, handler, context);
        }
 
        virtual Model::GetIntentsOutcome GetIntents(const Model::GetIntentsRequest& request = {}) const;
 
        template<typename GetIntentsRequestT = Model::GetIntentsRequest>
        Model::GetIntentsOutcomeCallable GetIntentsCallable(const GetIntentsRequestT& request = {}) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetIntents, request);
        }
 
        template<typename GetIntentsRequestT = Model::GetIntentsRequest>
        void GetIntentsAsync(const GetIntentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetIntentsRequestT& request = {}) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetIntents, request, handler, context);
        }
 
        virtual Model::GetMigrationOutcome GetMigration(const Model::GetMigrationRequest& request) const;
 
        template<typename GetMigrationRequestT = Model::GetMigrationRequest>
        Model::GetMigrationOutcomeCallable GetMigrationCallable(const GetMigrationRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetMigration, request);
        }
 
        template<typename GetMigrationRequestT = Model::GetMigrationRequest>
        void GetMigrationAsync(const GetMigrationRequestT& request, const GetMigrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetMigration, request, handler, context);
        }
 
        virtual Model::GetMigrationsOutcome GetMigrations(const Model::GetMigrationsRequest& request = {}) const;
 
        template<typename GetMigrationsRequestT = Model::GetMigrationsRequest>
        Model::GetMigrationsOutcomeCallable GetMigrationsCallable(const GetMigrationsRequestT& request = {}) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetMigrations, request);
        }
 
        template<typename GetMigrationsRequestT = Model::GetMigrationsRequest>
        void GetMigrationsAsync(const GetMigrationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetMigrationsRequestT& request = {}) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetMigrations, request, handler, context);
        }
 
        virtual Model::GetSlotTypeOutcome GetSlotType(const Model::GetSlotTypeRequest& request) const;
 
        template<typename GetSlotTypeRequestT = Model::GetSlotTypeRequest>
        Model::GetSlotTypeOutcomeCallable GetSlotTypeCallable(const GetSlotTypeRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetSlotType, request);
        }
 
        template<typename GetSlotTypeRequestT = Model::GetSlotTypeRequest>
        void GetSlotTypeAsync(const GetSlotTypeRequestT& request, const GetSlotTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetSlotType, request, handler, context);
        }
 
        virtual Model::GetSlotTypeVersionsOutcome GetSlotTypeVersions(const Model::GetSlotTypeVersionsRequest& request) const;
 
        template<typename GetSlotTypeVersionsRequestT = Model::GetSlotTypeVersionsRequest>
        Model::GetSlotTypeVersionsOutcomeCallable GetSlotTypeVersionsCallable(const GetSlotTypeVersionsRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetSlotTypeVersions, request);
        }
 
        template<typename GetSlotTypeVersionsRequestT = Model::GetSlotTypeVersionsRequest>
        void GetSlotTypeVersionsAsync(const GetSlotTypeVersionsRequestT& request, const GetSlotTypeVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetSlotTypeVersions, request, handler, context);
        }
 
        virtual Model::GetSlotTypesOutcome GetSlotTypes(const Model::GetSlotTypesRequest& request = {}) const;
 
        template<typename GetSlotTypesRequestT = Model::GetSlotTypesRequest>
        Model::GetSlotTypesOutcomeCallable GetSlotTypesCallable(const GetSlotTypesRequestT& request = {}) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetSlotTypes, request);
        }
 
        template<typename GetSlotTypesRequestT = Model::GetSlotTypesRequest>
        void GetSlotTypesAsync(const GetSlotTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetSlotTypesRequestT& request = {}) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetSlotTypes, request, handler, context);
        }
 
        virtual Model::GetUtterancesViewOutcome GetUtterancesView(const Model::GetUtterancesViewRequest& request) const;
 
        template<typename GetUtterancesViewRequestT = Model::GetUtterancesViewRequest>
        Model::GetUtterancesViewOutcomeCallable GetUtterancesViewCallable(const GetUtterancesViewRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::GetUtterancesView, request);
        }
 
        template<typename GetUtterancesViewRequestT = Model::GetUtterancesViewRequest>
        void GetUtterancesViewAsync(const GetUtterancesViewRequestT& request, const GetUtterancesViewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::GetUtterancesView, 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(&LexModelBuildingServiceClient::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(&LexModelBuildingServiceClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutBotOutcome PutBot(const Model::PutBotRequest& request) const;
 
        template<typename PutBotRequestT = Model::PutBotRequest>
        Model::PutBotOutcomeCallable PutBotCallable(const PutBotRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::PutBot, request);
        }
 
        template<typename PutBotRequestT = Model::PutBotRequest>
        void PutBotAsync(const PutBotRequestT& request, const PutBotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::PutBot, request, handler, context);
        }
 
        virtual Model::PutBotAliasOutcome PutBotAlias(const Model::PutBotAliasRequest& request) const;
 
        template<typename PutBotAliasRequestT = Model::PutBotAliasRequest>
        Model::PutBotAliasOutcomeCallable PutBotAliasCallable(const PutBotAliasRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::PutBotAlias, request);
        }
 
        template<typename PutBotAliasRequestT = Model::PutBotAliasRequest>
        void PutBotAliasAsync(const PutBotAliasRequestT& request, const PutBotAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::PutBotAlias, request, handler, context);
        }
 
        virtual Model::PutIntentOutcome PutIntent(const Model::PutIntentRequest& request) const;
 
        template<typename PutIntentRequestT = Model::PutIntentRequest>
        Model::PutIntentOutcomeCallable PutIntentCallable(const PutIntentRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::PutIntent, request);
        }
 
        template<typename PutIntentRequestT = Model::PutIntentRequest>
        void PutIntentAsync(const PutIntentRequestT& request, const PutIntentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::PutIntent, request, handler, context);
        }
 
        virtual Model::PutSlotTypeOutcome PutSlotType(const Model::PutSlotTypeRequest& request) const;
 
        template<typename PutSlotTypeRequestT = Model::PutSlotTypeRequest>
        Model::PutSlotTypeOutcomeCallable PutSlotTypeCallable(const PutSlotTypeRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::PutSlotType, request);
        }
 
        template<typename PutSlotTypeRequestT = Model::PutSlotTypeRequest>
        void PutSlotTypeAsync(const PutSlotTypeRequestT& request, const PutSlotTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::PutSlotType, 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(&LexModelBuildingServiceClient::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(&LexModelBuildingServiceClient::StartImport, request, handler, context);
        }
 
        virtual Model::StartMigrationOutcome StartMigration(const Model::StartMigrationRequest& request) const;
 
        template<typename StartMigrationRequestT = Model::StartMigrationRequest>
        Model::StartMigrationOutcomeCallable StartMigrationCallable(const StartMigrationRequestT& request) const
        {
            return SubmitCallable(&LexModelBuildingServiceClient::StartMigration, request);
        }
 
        template<typename StartMigrationRequestT = Model::StartMigrationRequest>
        void StartMigrationAsync(const StartMigrationRequestT& request, const StartMigrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LexModelBuildingServiceClient::StartMigration, 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(&LexModelBuildingServiceClient::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(&LexModelBuildingServiceClient::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(&LexModelBuildingServiceClient::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(&LexModelBuildingServiceClient::UntagResource, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<LexModelBuildingServiceEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<LexModelBuildingServiceClient>;
      void init(const LexModelBuildingServiceClientConfiguration& clientConfiguration);
 
      LexModelBuildingServiceClientConfiguration m_clientConfiguration;
      std::shared_ptr<LexModelBuildingServiceEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace LexModelBuildingService
} // namespace Aws