/*
 * Copyright 2009-2017 Alibaba Cloud All rights reserved.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <alibabacloud/chatbot/ChatbotClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>

using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::Chatbot;
using namespace AlibabaCloud::Chatbot::Model;

namespace
{
	const std::string SERVICE_NAME = "Chatbot";
}

ChatbotClient::ChatbotClient(const Credentials &credentials, const ClientConfiguration &configuration) :
	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "chatbot");
}

ChatbotClient::ChatbotClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "chatbot");
}

ChatbotClient::ChatbotClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "chatbot");
}

ChatbotClient::~ChatbotClient()
{}

ChatbotClient::ActivatePerspectiveOutcome ChatbotClient::activatePerspective(const ActivatePerspectiveRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return ActivatePerspectiveOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return ActivatePerspectiveOutcome(ActivatePerspectiveResult(outcome.result()));
	else
		return ActivatePerspectiveOutcome(outcome.error());
}

void ChatbotClient::activatePerspectiveAsync(const ActivatePerspectiveRequest& request, const ActivatePerspectiveAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, activatePerspective(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::ActivatePerspectiveOutcomeCallable ChatbotClient::activatePerspectiveCallable(const ActivatePerspectiveRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<ActivatePerspectiveOutcome()>>(
			[this, request]()
			{
			return this->activatePerspective(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::AddSynonymOutcome ChatbotClient::addSynonym(const AddSynonymRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return AddSynonymOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return AddSynonymOutcome(AddSynonymResult(outcome.result()));
	else
		return AddSynonymOutcome(outcome.error());
}

void ChatbotClient::addSynonymAsync(const AddSynonymRequest& request, const AddSynonymAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, addSynonym(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::AddSynonymOutcomeCallable ChatbotClient::addSynonymCallable(const AddSynonymRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<AddSynonymOutcome()>>(
			[this, request]()
			{
			return this->addSynonym(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::AppendEntityMemberOutcome ChatbotClient::appendEntityMember(const AppendEntityMemberRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return AppendEntityMemberOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return AppendEntityMemberOutcome(AppendEntityMemberResult(outcome.result()));
	else
		return AppendEntityMemberOutcome(outcome.error());
}

void ChatbotClient::appendEntityMemberAsync(const AppendEntityMemberRequest& request, const AppendEntityMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, appendEntityMember(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::AppendEntityMemberOutcomeCallable ChatbotClient::appendEntityMemberCallable(const AppendEntityMemberRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<AppendEntityMemberOutcome()>>(
			[this, request]()
			{
			return this->appendEntityMember(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::ChatOutcome ChatbotClient::chat(const ChatRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return ChatOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return ChatOutcome(ChatResult(outcome.result()));
	else
		return ChatOutcome(outcome.error());
}

void ChatbotClient::chatAsync(const ChatRequest& request, const ChatAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, chat(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::ChatOutcomeCallable ChatbotClient::chatCallable(const ChatRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<ChatOutcome()>>(
			[this, request]()
			{
			return this->chat(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::CreateBotOutcome ChatbotClient::createBot(const CreateBotRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return CreateBotOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return CreateBotOutcome(CreateBotResult(outcome.result()));
	else
		return CreateBotOutcome(outcome.error());
}

void ChatbotClient::createBotAsync(const CreateBotRequest& request, const CreateBotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, createBot(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::CreateBotOutcomeCallable ChatbotClient::createBotCallable(const CreateBotRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<CreateBotOutcome()>>(
			[this, request]()
			{
			return this->createBot(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::CreateCategoryOutcome ChatbotClient::createCategory(const CreateCategoryRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return CreateCategoryOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return CreateCategoryOutcome(CreateCategoryResult(outcome.result()));
	else
		return CreateCategoryOutcome(outcome.error());
}

void ChatbotClient::createCategoryAsync(const CreateCategoryRequest& request, const CreateCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, createCategory(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::CreateCategoryOutcomeCallable ChatbotClient::createCategoryCallable(const CreateCategoryRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<CreateCategoryOutcome()>>(
			[this, request]()
			{
			return this->createCategory(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::CreateCoreWordOutcome ChatbotClient::createCoreWord(const CreateCoreWordRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return CreateCoreWordOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return CreateCoreWordOutcome(CreateCoreWordResult(outcome.result()));
	else
		return CreateCoreWordOutcome(outcome.error());
}

void ChatbotClient::createCoreWordAsync(const CreateCoreWordRequest& request, const CreateCoreWordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, createCoreWord(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::CreateCoreWordOutcomeCallable ChatbotClient::createCoreWordCallable(const CreateCoreWordRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<CreateCoreWordOutcome()>>(
			[this, request]()
			{
			return this->createCoreWord(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::CreateDialogOutcome ChatbotClient::createDialog(const CreateDialogRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return CreateDialogOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return CreateDialogOutcome(CreateDialogResult(outcome.result()));
	else
		return CreateDialogOutcome(outcome.error());
}

void ChatbotClient::createDialogAsync(const CreateDialogRequest& request, const CreateDialogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, createDialog(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::CreateDialogOutcomeCallable ChatbotClient::createDialogCallable(const CreateDialogRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<CreateDialogOutcome()>>(
			[this, request]()
			{
			return this->createDialog(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::CreateEntityOutcome ChatbotClient::createEntity(const CreateEntityRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return CreateEntityOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return CreateEntityOutcome(CreateEntityResult(outcome.result()));
	else
		return CreateEntityOutcome(outcome.error());
}

void ChatbotClient::createEntityAsync(const CreateEntityRequest& request, const CreateEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, createEntity(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::CreateEntityOutcomeCallable ChatbotClient::createEntityCallable(const CreateEntityRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<CreateEntityOutcome()>>(
			[this, request]()
			{
			return this->createEntity(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::CreateIntentOutcome ChatbotClient::createIntent(const CreateIntentRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return CreateIntentOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return CreateIntentOutcome(CreateIntentResult(outcome.result()));
	else
		return CreateIntentOutcome(outcome.error());
}

void ChatbotClient::createIntentAsync(const CreateIntentRequest& request, const CreateIntentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, createIntent(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::CreateIntentOutcomeCallable ChatbotClient::createIntentCallable(const CreateIntentRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<CreateIntentOutcome()>>(
			[this, request]()
			{
			return this->createIntent(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::CreateKnowledgeOutcome ChatbotClient::createKnowledge(const CreateKnowledgeRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return CreateKnowledgeOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return CreateKnowledgeOutcome(CreateKnowledgeResult(outcome.result()));
	else
		return CreateKnowledgeOutcome(outcome.error());
}

void ChatbotClient::createKnowledgeAsync(const CreateKnowledgeRequest& request, const CreateKnowledgeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, createKnowledge(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::CreateKnowledgeOutcomeCallable ChatbotClient::createKnowledgeCallable(const CreateKnowledgeRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<CreateKnowledgeOutcome()>>(
			[this, request]()
			{
			return this->createKnowledge(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::CreatePerspectiveOutcome ChatbotClient::createPerspective(const CreatePerspectiveRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return CreatePerspectiveOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return CreatePerspectiveOutcome(CreatePerspectiveResult(outcome.result()));
	else
		return CreatePerspectiveOutcome(outcome.error());
}

void ChatbotClient::createPerspectiveAsync(const CreatePerspectiveRequest& request, const CreatePerspectiveAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, createPerspective(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::CreatePerspectiveOutcomeCallable ChatbotClient::createPerspectiveCallable(const CreatePerspectiveRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<CreatePerspectiveOutcome()>>(
			[this, request]()
			{
			return this->createPerspective(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::DeleteBotOutcome ChatbotClient::deleteBot(const DeleteBotRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DeleteBotOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DeleteBotOutcome(DeleteBotResult(outcome.result()));
	else
		return DeleteBotOutcome(outcome.error());
}

void ChatbotClient::deleteBotAsync(const DeleteBotRequest& request, const DeleteBotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, deleteBot(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::DeleteBotOutcomeCallable ChatbotClient::deleteBotCallable(const DeleteBotRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DeleteBotOutcome()>>(
			[this, request]()
			{
			return this->deleteBot(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::DeleteCategoryOutcome ChatbotClient::deleteCategory(const DeleteCategoryRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DeleteCategoryOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DeleteCategoryOutcome(DeleteCategoryResult(outcome.result()));
	else
		return DeleteCategoryOutcome(outcome.error());
}

void ChatbotClient::deleteCategoryAsync(const DeleteCategoryRequest& request, const DeleteCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, deleteCategory(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::DeleteCategoryOutcomeCallable ChatbotClient::deleteCategoryCallable(const DeleteCategoryRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DeleteCategoryOutcome()>>(
			[this, request]()
			{
			return this->deleteCategory(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::DeleteCoreWordOutcome ChatbotClient::deleteCoreWord(const DeleteCoreWordRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DeleteCoreWordOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DeleteCoreWordOutcome(DeleteCoreWordResult(outcome.result()));
	else
		return DeleteCoreWordOutcome(outcome.error());
}

void ChatbotClient::deleteCoreWordAsync(const DeleteCoreWordRequest& request, const DeleteCoreWordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, deleteCoreWord(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::DeleteCoreWordOutcomeCallable ChatbotClient::deleteCoreWordCallable(const DeleteCoreWordRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DeleteCoreWordOutcome()>>(
			[this, request]()
			{
			return this->deleteCoreWord(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::DeleteDialogOutcome ChatbotClient::deleteDialog(const DeleteDialogRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DeleteDialogOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DeleteDialogOutcome(DeleteDialogResult(outcome.result()));
	else
		return DeleteDialogOutcome(outcome.error());
}

void ChatbotClient::deleteDialogAsync(const DeleteDialogRequest& request, const DeleteDialogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, deleteDialog(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::DeleteDialogOutcomeCallable ChatbotClient::deleteDialogCallable(const DeleteDialogRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DeleteDialogOutcome()>>(
			[this, request]()
			{
			return this->deleteDialog(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::DeleteEntityOutcome ChatbotClient::deleteEntity(const DeleteEntityRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DeleteEntityOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DeleteEntityOutcome(DeleteEntityResult(outcome.result()));
	else
		return DeleteEntityOutcome(outcome.error());
}

void ChatbotClient::deleteEntityAsync(const DeleteEntityRequest& request, const DeleteEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, deleteEntity(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::DeleteEntityOutcomeCallable ChatbotClient::deleteEntityCallable(const DeleteEntityRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DeleteEntityOutcome()>>(
			[this, request]()
			{
			return this->deleteEntity(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::DeleteIntentOutcome ChatbotClient::deleteIntent(const DeleteIntentRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DeleteIntentOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DeleteIntentOutcome(DeleteIntentResult(outcome.result()));
	else
		return DeleteIntentOutcome(outcome.error());
}

void ChatbotClient::deleteIntentAsync(const DeleteIntentRequest& request, const DeleteIntentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, deleteIntent(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::DeleteIntentOutcomeCallable ChatbotClient::deleteIntentCallable(const DeleteIntentRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DeleteIntentOutcome()>>(
			[this, request]()
			{
			return this->deleteIntent(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::DeleteKnowledgeOutcome ChatbotClient::deleteKnowledge(const DeleteKnowledgeRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DeleteKnowledgeOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DeleteKnowledgeOutcome(DeleteKnowledgeResult(outcome.result()));
	else
		return DeleteKnowledgeOutcome(outcome.error());
}

void ChatbotClient::deleteKnowledgeAsync(const DeleteKnowledgeRequest& request, const DeleteKnowledgeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, deleteKnowledge(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::DeleteKnowledgeOutcomeCallable ChatbotClient::deleteKnowledgeCallable(const DeleteKnowledgeRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DeleteKnowledgeOutcome()>>(
			[this, request]()
			{
			return this->deleteKnowledge(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::DescribeBotOutcome ChatbotClient::describeBot(const DescribeBotRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DescribeBotOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DescribeBotOutcome(DescribeBotResult(outcome.result()));
	else
		return DescribeBotOutcome(outcome.error());
}

void ChatbotClient::describeBotAsync(const DescribeBotRequest& request, const DescribeBotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, describeBot(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::DescribeBotOutcomeCallable ChatbotClient::describeBotCallable(const DescribeBotRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DescribeBotOutcome()>>(
			[this, request]()
			{
			return this->describeBot(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::DescribeCategoryOutcome ChatbotClient::describeCategory(const DescribeCategoryRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DescribeCategoryOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DescribeCategoryOutcome(DescribeCategoryResult(outcome.result()));
	else
		return DescribeCategoryOutcome(outcome.error());
}

void ChatbotClient::describeCategoryAsync(const DescribeCategoryRequest& request, const DescribeCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, describeCategory(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::DescribeCategoryOutcomeCallable ChatbotClient::describeCategoryCallable(const DescribeCategoryRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DescribeCategoryOutcome()>>(
			[this, request]()
			{
			return this->describeCategory(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::DescribeCoreWordOutcome ChatbotClient::describeCoreWord(const DescribeCoreWordRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DescribeCoreWordOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DescribeCoreWordOutcome(DescribeCoreWordResult(outcome.result()));
	else
		return DescribeCoreWordOutcome(outcome.error());
}

void ChatbotClient::describeCoreWordAsync(const DescribeCoreWordRequest& request, const DescribeCoreWordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, describeCoreWord(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::DescribeCoreWordOutcomeCallable ChatbotClient::describeCoreWordCallable(const DescribeCoreWordRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DescribeCoreWordOutcome()>>(
			[this, request]()
			{
			return this->describeCoreWord(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::DescribeDialogOutcome ChatbotClient::describeDialog(const DescribeDialogRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DescribeDialogOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DescribeDialogOutcome(DescribeDialogResult(outcome.result()));
	else
		return DescribeDialogOutcome(outcome.error());
}

void ChatbotClient::describeDialogAsync(const DescribeDialogRequest& request, const DescribeDialogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, describeDialog(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::DescribeDialogOutcomeCallable ChatbotClient::describeDialogCallable(const DescribeDialogRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DescribeDialogOutcome()>>(
			[this, request]()
			{
			return this->describeDialog(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::DescribeDialogFlowOutcome ChatbotClient::describeDialogFlow(const DescribeDialogFlowRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DescribeDialogFlowOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DescribeDialogFlowOutcome(DescribeDialogFlowResult(outcome.result()));
	else
		return DescribeDialogFlowOutcome(outcome.error());
}

void ChatbotClient::describeDialogFlowAsync(const DescribeDialogFlowRequest& request, const DescribeDialogFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, describeDialogFlow(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::DescribeDialogFlowOutcomeCallable ChatbotClient::describeDialogFlowCallable(const DescribeDialogFlowRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DescribeDialogFlowOutcome()>>(
			[this, request]()
			{
			return this->describeDialogFlow(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::DescribeEntitiesOutcome ChatbotClient::describeEntities(const DescribeEntitiesRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DescribeEntitiesOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DescribeEntitiesOutcome(DescribeEntitiesResult(outcome.result()));
	else
		return DescribeEntitiesOutcome(outcome.error());
}

void ChatbotClient::describeEntitiesAsync(const DescribeEntitiesRequest& request, const DescribeEntitiesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, describeEntities(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::DescribeEntitiesOutcomeCallable ChatbotClient::describeEntitiesCallable(const DescribeEntitiesRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DescribeEntitiesOutcome()>>(
			[this, request]()
			{
			return this->describeEntities(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::DescribeIntentOutcome ChatbotClient::describeIntent(const DescribeIntentRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DescribeIntentOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DescribeIntentOutcome(DescribeIntentResult(outcome.result()));
	else
		return DescribeIntentOutcome(outcome.error());
}

void ChatbotClient::describeIntentAsync(const DescribeIntentRequest& request, const DescribeIntentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, describeIntent(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::DescribeIntentOutcomeCallable ChatbotClient::describeIntentCallable(const DescribeIntentRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DescribeIntentOutcome()>>(
			[this, request]()
			{
			return this->describeIntent(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::DescribeKnowledgeOutcome ChatbotClient::describeKnowledge(const DescribeKnowledgeRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DescribeKnowledgeOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DescribeKnowledgeOutcome(DescribeKnowledgeResult(outcome.result()));
	else
		return DescribeKnowledgeOutcome(outcome.error());
}

void ChatbotClient::describeKnowledgeAsync(const DescribeKnowledgeRequest& request, const DescribeKnowledgeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, describeKnowledge(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::DescribeKnowledgeOutcomeCallable ChatbotClient::describeKnowledgeCallable(const DescribeKnowledgeRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DescribeKnowledgeOutcome()>>(
			[this, request]()
			{
			return this->describeKnowledge(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::DescribePerspectiveOutcome ChatbotClient::describePerspective(const DescribePerspectiveRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DescribePerspectiveOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DescribePerspectiveOutcome(DescribePerspectiveResult(outcome.result()));
	else
		return DescribePerspectiveOutcome(outcome.error());
}

void ChatbotClient::describePerspectiveAsync(const DescribePerspectiveRequest& request, const DescribePerspectiveAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, describePerspective(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::DescribePerspectiveOutcomeCallable ChatbotClient::describePerspectiveCallable(const DescribePerspectiveRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DescribePerspectiveOutcome()>>(
			[this, request]()
			{
			return this->describePerspective(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::DisableDialogFlowOutcome ChatbotClient::disableDialogFlow(const DisableDialogFlowRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DisableDialogFlowOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DisableDialogFlowOutcome(DisableDialogFlowResult(outcome.result()));
	else
		return DisableDialogFlowOutcome(outcome.error());
}

void ChatbotClient::disableDialogFlowAsync(const DisableDialogFlowRequest& request, const DisableDialogFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, disableDialogFlow(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::DisableDialogFlowOutcomeCallable ChatbotClient::disableDialogFlowCallable(const DisableDialogFlowRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DisableDialogFlowOutcome()>>(
			[this, request]()
			{
			return this->disableDialogFlow(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::DisableKnowledgeOutcome ChatbotClient::disableKnowledge(const DisableKnowledgeRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DisableKnowledgeOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DisableKnowledgeOutcome(DisableKnowledgeResult(outcome.result()));
	else
		return DisableKnowledgeOutcome(outcome.error());
}

void ChatbotClient::disableKnowledgeAsync(const DisableKnowledgeRequest& request, const DisableKnowledgeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, disableKnowledge(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::DisableKnowledgeOutcomeCallable ChatbotClient::disableKnowledgeCallable(const DisableKnowledgeRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DisableKnowledgeOutcome()>>(
			[this, request]()
			{
			return this->disableKnowledge(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::FeedbackOutcome ChatbotClient::feedback(const FeedbackRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return FeedbackOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return FeedbackOutcome(FeedbackResult(outcome.result()));
	else
		return FeedbackOutcome(outcome.error());
}

void ChatbotClient::feedbackAsync(const FeedbackRequest& request, const FeedbackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, feedback(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::FeedbackOutcomeCallable ChatbotClient::feedbackCallable(const FeedbackRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<FeedbackOutcome()>>(
			[this, request]()
			{
			return this->feedback(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::LinkBotCategoryOutcome ChatbotClient::linkBotCategory(const LinkBotCategoryRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return LinkBotCategoryOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return LinkBotCategoryOutcome(LinkBotCategoryResult(outcome.result()));
	else
		return LinkBotCategoryOutcome(outcome.error());
}

void ChatbotClient::linkBotCategoryAsync(const LinkBotCategoryRequest& request, const LinkBotCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, linkBotCategory(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::LinkBotCategoryOutcomeCallable ChatbotClient::linkBotCategoryCallable(const LinkBotCategoryRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<LinkBotCategoryOutcome()>>(
			[this, request]()
			{
			return this->linkBotCategory(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::MoveKnowledgeCategoryOutcome ChatbotClient::moveKnowledgeCategory(const MoveKnowledgeCategoryRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return MoveKnowledgeCategoryOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return MoveKnowledgeCategoryOutcome(MoveKnowledgeCategoryResult(outcome.result()));
	else
		return MoveKnowledgeCategoryOutcome(outcome.error());
}

void ChatbotClient::moveKnowledgeCategoryAsync(const MoveKnowledgeCategoryRequest& request, const MoveKnowledgeCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, moveKnowledgeCategory(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::MoveKnowledgeCategoryOutcomeCallable ChatbotClient::moveKnowledgeCategoryCallable(const MoveKnowledgeCategoryRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<MoveKnowledgeCategoryOutcome()>>(
			[this, request]()
			{
			return this->moveKnowledgeCategory(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::PublishDialogFlowOutcome ChatbotClient::publishDialogFlow(const PublishDialogFlowRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return PublishDialogFlowOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return PublishDialogFlowOutcome(PublishDialogFlowResult(outcome.result()));
	else
		return PublishDialogFlowOutcome(outcome.error());
}

void ChatbotClient::publishDialogFlowAsync(const PublishDialogFlowRequest& request, const PublishDialogFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, publishDialogFlow(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::PublishDialogFlowOutcomeCallable ChatbotClient::publishDialogFlowCallable(const PublishDialogFlowRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<PublishDialogFlowOutcome()>>(
			[this, request]()
			{
			return this->publishDialogFlow(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::PublishKnowledgeOutcome ChatbotClient::publishKnowledge(const PublishKnowledgeRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return PublishKnowledgeOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return PublishKnowledgeOutcome(PublishKnowledgeResult(outcome.result()));
	else
		return PublishKnowledgeOutcome(outcome.error());
}

void ChatbotClient::publishKnowledgeAsync(const PublishKnowledgeRequest& request, const PublishKnowledgeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, publishKnowledge(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::PublishKnowledgeOutcomeCallable ChatbotClient::publishKnowledgeCallable(const PublishKnowledgeRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<PublishKnowledgeOutcome()>>(
			[this, request]()
			{
			return this->publishKnowledge(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::QueryBotsOutcome ChatbotClient::queryBots(const QueryBotsRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return QueryBotsOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return QueryBotsOutcome(QueryBotsResult(outcome.result()));
	else
		return QueryBotsOutcome(outcome.error());
}

void ChatbotClient::queryBotsAsync(const QueryBotsRequest& request, const QueryBotsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, queryBots(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::QueryBotsOutcomeCallable ChatbotClient::queryBotsCallable(const QueryBotsRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<QueryBotsOutcome()>>(
			[this, request]()
			{
			return this->queryBots(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::QueryCategoriesOutcome ChatbotClient::queryCategories(const QueryCategoriesRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return QueryCategoriesOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return QueryCategoriesOutcome(QueryCategoriesResult(outcome.result()));
	else
		return QueryCategoriesOutcome(outcome.error());
}

void ChatbotClient::queryCategoriesAsync(const QueryCategoriesRequest& request, const QueryCategoriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, queryCategories(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::QueryCategoriesOutcomeCallable ChatbotClient::queryCategoriesCallable(const QueryCategoriesRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<QueryCategoriesOutcome()>>(
			[this, request]()
			{
			return this->queryCategories(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::QueryCoreWordsOutcome ChatbotClient::queryCoreWords(const QueryCoreWordsRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return QueryCoreWordsOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return QueryCoreWordsOutcome(QueryCoreWordsResult(outcome.result()));
	else
		return QueryCoreWordsOutcome(outcome.error());
}

void ChatbotClient::queryCoreWordsAsync(const QueryCoreWordsRequest& request, const QueryCoreWordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, queryCoreWords(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::QueryCoreWordsOutcomeCallable ChatbotClient::queryCoreWordsCallable(const QueryCoreWordsRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<QueryCoreWordsOutcome()>>(
			[this, request]()
			{
			return this->queryCoreWords(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::QueryDialogsOutcome ChatbotClient::queryDialogs(const QueryDialogsRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return QueryDialogsOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return QueryDialogsOutcome(QueryDialogsResult(outcome.result()));
	else
		return QueryDialogsOutcome(outcome.error());
}

void ChatbotClient::queryDialogsAsync(const QueryDialogsRequest& request, const QueryDialogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, queryDialogs(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::QueryDialogsOutcomeCallable ChatbotClient::queryDialogsCallable(const QueryDialogsRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<QueryDialogsOutcome()>>(
			[this, request]()
			{
			return this->queryDialogs(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::QueryEntitiesOutcome ChatbotClient::queryEntities(const QueryEntitiesRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return QueryEntitiesOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return QueryEntitiesOutcome(QueryEntitiesResult(outcome.result()));
	else
		return QueryEntitiesOutcome(outcome.error());
}

void ChatbotClient::queryEntitiesAsync(const QueryEntitiesRequest& request, const QueryEntitiesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, queryEntities(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::QueryEntitiesOutcomeCallable ChatbotClient::queryEntitiesCallable(const QueryEntitiesRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<QueryEntitiesOutcome()>>(
			[this, request]()
			{
			return this->queryEntities(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::QueryIntentsOutcome ChatbotClient::queryIntents(const QueryIntentsRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return QueryIntentsOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return QueryIntentsOutcome(QueryIntentsResult(outcome.result()));
	else
		return QueryIntentsOutcome(outcome.error());
}

void ChatbotClient::queryIntentsAsync(const QueryIntentsRequest& request, const QueryIntentsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, queryIntents(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::QueryIntentsOutcomeCallable ChatbotClient::queryIntentsCallable(const QueryIntentsRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<QueryIntentsOutcome()>>(
			[this, request]()
			{
			return this->queryIntents(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::QueryKnowledgesOutcome ChatbotClient::queryKnowledges(const QueryKnowledgesRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return QueryKnowledgesOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return QueryKnowledgesOutcome(QueryKnowledgesResult(outcome.result()));
	else
		return QueryKnowledgesOutcome(outcome.error());
}

void ChatbotClient::queryKnowledgesAsync(const QueryKnowledgesRequest& request, const QueryKnowledgesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, queryKnowledges(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::QueryKnowledgesOutcomeCallable ChatbotClient::queryKnowledgesCallable(const QueryKnowledgesRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<QueryKnowledgesOutcome()>>(
			[this, request]()
			{
			return this->queryKnowledges(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::QueryPerspectivesOutcome ChatbotClient::queryPerspectives(const QueryPerspectivesRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return QueryPerspectivesOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return QueryPerspectivesOutcome(QueryPerspectivesResult(outcome.result()));
	else
		return QueryPerspectivesOutcome(outcome.error());
}

void ChatbotClient::queryPerspectivesAsync(const QueryPerspectivesRequest& request, const QueryPerspectivesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, queryPerspectives(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::QueryPerspectivesOutcomeCallable ChatbotClient::queryPerspectivesCallable(const QueryPerspectivesRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<QueryPerspectivesOutcome()>>(
			[this, request]()
			{
			return this->queryPerspectives(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::QuerySystemEntitiesOutcome ChatbotClient::querySystemEntities(const QuerySystemEntitiesRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return QuerySystemEntitiesOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return QuerySystemEntitiesOutcome(QuerySystemEntitiesResult(outcome.result()));
	else
		return QuerySystemEntitiesOutcome(outcome.error());
}

void ChatbotClient::querySystemEntitiesAsync(const QuerySystemEntitiesRequest& request, const QuerySystemEntitiesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, querySystemEntities(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::QuerySystemEntitiesOutcomeCallable ChatbotClient::querySystemEntitiesCallable(const QuerySystemEntitiesRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<QuerySystemEntitiesOutcome()>>(
			[this, request]()
			{
			return this->querySystemEntities(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::RemoveEntityMemberOutcome ChatbotClient::removeEntityMember(const RemoveEntityMemberRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return RemoveEntityMemberOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return RemoveEntityMemberOutcome(RemoveEntityMemberResult(outcome.result()));
	else
		return RemoveEntityMemberOutcome(outcome.error());
}

void ChatbotClient::removeEntityMemberAsync(const RemoveEntityMemberRequest& request, const RemoveEntityMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, removeEntityMember(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::RemoveEntityMemberOutcomeCallable ChatbotClient::removeEntityMemberCallable(const RemoveEntityMemberRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<RemoveEntityMemberOutcome()>>(
			[this, request]()
			{
			return this->removeEntityMember(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::RemoveSynonymOutcome ChatbotClient::removeSynonym(const RemoveSynonymRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return RemoveSynonymOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return RemoveSynonymOutcome(RemoveSynonymResult(outcome.result()));
	else
		return RemoveSynonymOutcome(outcome.error());
}

void ChatbotClient::removeSynonymAsync(const RemoveSynonymRequest& request, const RemoveSynonymAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, removeSynonym(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::RemoveSynonymOutcomeCallable ChatbotClient::removeSynonymCallable(const RemoveSynonymRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<RemoveSynonymOutcome()>>(
			[this, request]()
			{
			return this->removeSynonym(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::TestDialogFlowOutcome ChatbotClient::testDialogFlow(const TestDialogFlowRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return TestDialogFlowOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return TestDialogFlowOutcome(TestDialogFlowResult(outcome.result()));
	else
		return TestDialogFlowOutcome(outcome.error());
}

void ChatbotClient::testDialogFlowAsync(const TestDialogFlowRequest& request, const TestDialogFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, testDialogFlow(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::TestDialogFlowOutcomeCallable ChatbotClient::testDialogFlowCallable(const TestDialogFlowRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<TestDialogFlowOutcome()>>(
			[this, request]()
			{
			return this->testDialogFlow(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::UpdateCategoryOutcome ChatbotClient::updateCategory(const UpdateCategoryRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return UpdateCategoryOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return UpdateCategoryOutcome(UpdateCategoryResult(outcome.result()));
	else
		return UpdateCategoryOutcome(outcome.error());
}

void ChatbotClient::updateCategoryAsync(const UpdateCategoryRequest& request, const UpdateCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, updateCategory(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::UpdateCategoryOutcomeCallable ChatbotClient::updateCategoryCallable(const UpdateCategoryRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<UpdateCategoryOutcome()>>(
			[this, request]()
			{
			return this->updateCategory(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::UpdateCoreWordOutcome ChatbotClient::updateCoreWord(const UpdateCoreWordRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return UpdateCoreWordOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return UpdateCoreWordOutcome(UpdateCoreWordResult(outcome.result()));
	else
		return UpdateCoreWordOutcome(outcome.error());
}

void ChatbotClient::updateCoreWordAsync(const UpdateCoreWordRequest& request, const UpdateCoreWordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, updateCoreWord(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::UpdateCoreWordOutcomeCallable ChatbotClient::updateCoreWordCallable(const UpdateCoreWordRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<UpdateCoreWordOutcome()>>(
			[this, request]()
			{
			return this->updateCoreWord(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::UpdateDialogOutcome ChatbotClient::updateDialog(const UpdateDialogRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return UpdateDialogOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return UpdateDialogOutcome(UpdateDialogResult(outcome.result()));
	else
		return UpdateDialogOutcome(outcome.error());
}

void ChatbotClient::updateDialogAsync(const UpdateDialogRequest& request, const UpdateDialogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, updateDialog(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::UpdateDialogOutcomeCallable ChatbotClient::updateDialogCallable(const UpdateDialogRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<UpdateDialogOutcome()>>(
			[this, request]()
			{
			return this->updateDialog(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::UpdateDialogFlowOutcome ChatbotClient::updateDialogFlow(const UpdateDialogFlowRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return UpdateDialogFlowOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return UpdateDialogFlowOutcome(UpdateDialogFlowResult(outcome.result()));
	else
		return UpdateDialogFlowOutcome(outcome.error());
}

void ChatbotClient::updateDialogFlowAsync(const UpdateDialogFlowRequest& request, const UpdateDialogFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, updateDialogFlow(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::UpdateDialogFlowOutcomeCallable ChatbotClient::updateDialogFlowCallable(const UpdateDialogFlowRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<UpdateDialogFlowOutcome()>>(
			[this, request]()
			{
			return this->updateDialogFlow(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::UpdateEntityOutcome ChatbotClient::updateEntity(const UpdateEntityRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return UpdateEntityOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return UpdateEntityOutcome(UpdateEntityResult(outcome.result()));
	else
		return UpdateEntityOutcome(outcome.error());
}

void ChatbotClient::updateEntityAsync(const UpdateEntityRequest& request, const UpdateEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, updateEntity(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::UpdateEntityOutcomeCallable ChatbotClient::updateEntityCallable(const UpdateEntityRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<UpdateEntityOutcome()>>(
			[this, request]()
			{
			return this->updateEntity(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::UpdateIntentOutcome ChatbotClient::updateIntent(const UpdateIntentRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return UpdateIntentOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return UpdateIntentOutcome(UpdateIntentResult(outcome.result()));
	else
		return UpdateIntentOutcome(outcome.error());
}

void ChatbotClient::updateIntentAsync(const UpdateIntentRequest& request, const UpdateIntentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, updateIntent(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::UpdateIntentOutcomeCallable ChatbotClient::updateIntentCallable(const UpdateIntentRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<UpdateIntentOutcome()>>(
			[this, request]()
			{
			return this->updateIntent(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::UpdateKnowledgeOutcome ChatbotClient::updateKnowledge(const UpdateKnowledgeRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return UpdateKnowledgeOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return UpdateKnowledgeOutcome(UpdateKnowledgeResult(outcome.result()));
	else
		return UpdateKnowledgeOutcome(outcome.error());
}

void ChatbotClient::updateKnowledgeAsync(const UpdateKnowledgeRequest& request, const UpdateKnowledgeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, updateKnowledge(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::UpdateKnowledgeOutcomeCallable ChatbotClient::updateKnowledgeCallable(const UpdateKnowledgeRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<UpdateKnowledgeOutcome()>>(
			[this, request]()
			{
			return this->updateKnowledge(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ChatbotClient::UpdatePerspectiveOutcome ChatbotClient::updatePerspective(const UpdatePerspectiveRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return UpdatePerspectiveOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return UpdatePerspectiveOutcome(UpdatePerspectiveResult(outcome.result()));
	else
		return UpdatePerspectiveOutcome(outcome.error());
}

void ChatbotClient::updatePerspectiveAsync(const UpdatePerspectiveRequest& request, const UpdatePerspectiveAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, updatePerspective(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ChatbotClient::UpdatePerspectiveOutcomeCallable ChatbotClient::updatePerspectiveCallable(const UpdatePerspectiveRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<UpdatePerspectiveOutcome()>>(
			[this, request]()
			{
			return this->updatePerspective(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}