SLB SDK Auto Released By laysong.sl,Version：1.23.4

Signed-off-by: yixiong.jxy <yixiong.jxy@alibaba-inc.com>

slb/src/SlbClient.cc

@@ -51,6 +51,42 @@ SlbClient::SlbClient(const std::string & accessKeyId, const std::string & access
 SlbClient::~SlbClient()
 {}
 
+SlbClient::SetDomainExtensionAttributeOutcome SlbClient::setDomainExtensionAttribute(const SetDomainExtensionAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetDomainExtensionAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetDomainExtensionAttributeOutcome(SetDomainExtensionAttributeResult(outcome.result()));
+	else
+		return SetDomainExtensionAttributeOutcome(outcome.error());
+}
+
+void SlbClient::setDomainExtensionAttributeAsync(const SetDomainExtensionAttributeRequest& request, const SetDomainExtensionAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setDomainExtensionAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SlbClient::SetDomainExtensionAttributeOutcomeCallable SlbClient::setDomainExtensionAttributeCallable(const SetDomainExtensionAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetDomainExtensionAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->setDomainExtensionAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SlbClient::CreateLoadBalancerUDPListenerOutcome SlbClient::createLoadBalancerUDPListener(const CreateLoadBalancerUDPListenerRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -627,6 +663,42 @@ SlbClient::SetLoadBalancerHTTPListenerAttributeOutcomeCallable SlbClient::setLoa
 	return task->get_future();
 }
 
+SlbClient::DescribeDomainExtensionsOutcome SlbClient::describeDomainExtensions(const DescribeDomainExtensionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDomainExtensionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDomainExtensionsOutcome(DescribeDomainExtensionsResult(outcome.result()));
+	else
+		return DescribeDomainExtensionsOutcome(outcome.error());
+}
+
+void SlbClient::describeDomainExtensionsAsync(const DescribeDomainExtensionsRequest& request, const DescribeDomainExtensionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDomainExtensions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SlbClient::DescribeDomainExtensionsOutcomeCallable SlbClient::describeDomainExtensionsCallable(const DescribeDomainExtensionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDomainExtensionsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDomainExtensions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SlbClient::SetLoadBalancerAutoReleaseTimeOutcome SlbClient::setLoadBalancerAutoReleaseTime(const SetLoadBalancerAutoReleaseTimeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -807,6 +879,42 @@ SlbClient::SetLoadBalancerHTTPSListenerAttributeOutcomeCallable SlbClient::setLo
 	return task->get_future();
 }
 
+SlbClient::SetAutoRenewStatusOutcome SlbClient::setAutoRenewStatus(const SetAutoRenewStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetAutoRenewStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetAutoRenewStatusOutcome(SetAutoRenewStatusResult(outcome.result()));
+	else
+		return SetAutoRenewStatusOutcome(outcome.error());
+}
+
+void SlbClient::setAutoRenewStatusAsync(const SetAutoRenewStatusRequest& request, const SetAutoRenewStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setAutoRenewStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SlbClient::SetAutoRenewStatusOutcomeCallable SlbClient::setAutoRenewStatusCallable(const SetAutoRenewStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetAutoRenewStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->setAutoRenewStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SlbClient::DeleteLoadBalancerListenerOutcome SlbClient::deleteLoadBalancerListener(const DeleteLoadBalancerListenerRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1239,6 +1347,42 @@ SlbClient::RemoveBackendServersOutcomeCallable SlbClient::removeBackendServersCa
 	return task->get_future();
 }
 
+SlbClient::AddAccessControlListEntryOutcome SlbClient::addAccessControlListEntry(const AddAccessControlListEntryRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddAccessControlListEntryOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddAccessControlListEntryOutcome(AddAccessControlListEntryResult(outcome.result()));
+	else
+		return AddAccessControlListEntryOutcome(outcome.error());
+}
+
+void SlbClient::addAccessControlListEntryAsync(const AddAccessControlListEntryRequest& request, const AddAccessControlListEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addAccessControlListEntry(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SlbClient::AddAccessControlListEntryOutcomeCallable SlbClient::addAccessControlListEntryCallable(const AddAccessControlListEntryRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddAccessControlListEntryOutcome()>>(
+			[this, request]()
+			{
+			return this->addAccessControlListEntry(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SlbClient::ModifyVServerGroupBackendServersOutcome SlbClient::modifyVServerGroupBackendServers(const ModifyVServerGroupBackendServersRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1275,6 +1419,42 @@ SlbClient::ModifyVServerGroupBackendServersOutcomeCallable SlbClient::modifyVSer
 	return task->get_future();
 }
 
+SlbClient::DescribeSlbQuotasOutcome SlbClient::describeSlbQuotas(const DescribeSlbQuotasRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeSlbQuotasOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeSlbQuotasOutcome(DescribeSlbQuotasResult(outcome.result()));
+	else
+		return DescribeSlbQuotasOutcome(outcome.error());
+}
+
+void SlbClient::describeSlbQuotasAsync(const DescribeSlbQuotasRequest& request, const DescribeSlbQuotasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeSlbQuotas(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SlbClient::DescribeSlbQuotasOutcomeCallable SlbClient::describeSlbQuotasCallable(const DescribeSlbQuotasRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeSlbQuotasOutcome()>>(
+			[this, request]()
+			{
+			return this->describeSlbQuotas(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SlbClient::DescribeLoadBalancerUDPListenerAttributeOutcome SlbClient::describeLoadBalancerUDPListenerAttribute(const DescribeLoadBalancerUDPListenerAttributeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1491,6 +1671,42 @@ SlbClient::SetBackendServersOutcomeCallable SlbClient::setBackendServersCallable
 	return task->get_future();
 }
 
+SlbClient::DeleteAccessControlListOutcome SlbClient::deleteAccessControlList(const DeleteAccessControlListRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteAccessControlListOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteAccessControlListOutcome(DeleteAccessControlListResult(outcome.result()));
+	else
+		return DeleteAccessControlListOutcome(outcome.error());
+}
+
+void SlbClient::deleteAccessControlListAsync(const DeleteAccessControlListRequest& request, const DeleteAccessControlListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteAccessControlList(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SlbClient::DeleteAccessControlListOutcomeCallable SlbClient::deleteAccessControlListCallable(const DeleteAccessControlListRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteAccessControlListOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteAccessControlList(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SlbClient::RemoveVServerGroupBackendServersOutcome SlbClient::removeVServerGroupBackendServers(const RemoveVServerGroupBackendServersRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1671,6 +1887,42 @@ SlbClient::DeleteCACertificateOutcomeCallable SlbClient::deleteCACertificateCall
 	return task->get_future();
 }
 
+SlbClient::SetAccessControlListAttributeOutcome SlbClient::setAccessControlListAttribute(const SetAccessControlListAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetAccessControlListAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetAccessControlListAttributeOutcome(SetAccessControlListAttributeResult(outcome.result()));
+	else
+		return SetAccessControlListAttributeOutcome(outcome.error());
+}
+
+void SlbClient::setAccessControlListAttributeAsync(const SetAccessControlListAttributeRequest& request, const SetAccessControlListAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setAccessControlListAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SlbClient::SetAccessControlListAttributeOutcomeCallable SlbClient::setAccessControlListAttributeCallable(const SetAccessControlListAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetAccessControlListAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->setAccessControlListAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SlbClient::CreateLoadBalancerTCPListenerOutcome SlbClient::createLoadBalancerTCPListener(const CreateLoadBalancerTCPListenerRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1707,6 +1959,114 @@ SlbClient::CreateLoadBalancerTCPListenerOutcomeCallable SlbClient::createLoadBal
 	return task->get_future();
 }
 
+SlbClient::DescribeAccessControlListAttributeOutcome SlbClient::describeAccessControlListAttribute(const DescribeAccessControlListAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeAccessControlListAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeAccessControlListAttributeOutcome(DescribeAccessControlListAttributeResult(outcome.result()));
+	else
+		return DescribeAccessControlListAttributeOutcome(outcome.error());
+}
+
+void SlbClient::describeAccessControlListAttributeAsync(const DescribeAccessControlListAttributeRequest& request, const DescribeAccessControlListAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeAccessControlListAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SlbClient::DescribeAccessControlListAttributeOutcomeCallable SlbClient::describeAccessControlListAttributeCallable(const DescribeAccessControlListAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeAccessControlListAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->describeAccessControlListAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SlbClient::DescribeAccessControlListsOutcome SlbClient::describeAccessControlLists(const DescribeAccessControlListsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeAccessControlListsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeAccessControlListsOutcome(DescribeAccessControlListsResult(outcome.result()));
+	else
+		return DescribeAccessControlListsOutcome(outcome.error());
+}
+
+void SlbClient::describeAccessControlListsAsync(const DescribeAccessControlListsRequest& request, const DescribeAccessControlListsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeAccessControlLists(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SlbClient::DescribeAccessControlListsOutcomeCallable SlbClient::describeAccessControlListsCallable(const DescribeAccessControlListsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeAccessControlListsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeAccessControlLists(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SlbClient::DeleteDomainExtensionOutcome SlbClient::deleteDomainExtension(const DeleteDomainExtensionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteDomainExtensionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteDomainExtensionOutcome(DeleteDomainExtensionResult(outcome.result()));
+	else
+		return DeleteDomainExtensionOutcome(outcome.error());
+}
+
+void SlbClient::deleteDomainExtensionAsync(const DeleteDomainExtensionRequest& request, const DeleteDomainExtensionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteDomainExtension(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SlbClient::DeleteDomainExtensionOutcomeCallable SlbClient::deleteDomainExtensionCallable(const DeleteDomainExtensionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteDomainExtensionOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteDomainExtension(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SlbClient::SetRuleOutcome SlbClient::setRule(const SetRuleRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2031,6 +2391,78 @@ SlbClient::DescribeRulesOutcomeCallable SlbClient::describeRulesCallable(const D
 	return task->get_future();
 }
 
+SlbClient::RemoveAccessControlListEntryOutcome SlbClient::removeAccessControlListEntry(const RemoveAccessControlListEntryRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RemoveAccessControlListEntryOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RemoveAccessControlListEntryOutcome(RemoveAccessControlListEntryResult(outcome.result()));
+	else
+		return RemoveAccessControlListEntryOutcome(outcome.error());
+}
+
+void SlbClient::removeAccessControlListEntryAsync(const RemoveAccessControlListEntryRequest& request, const RemoveAccessControlListEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, removeAccessControlListEntry(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SlbClient::RemoveAccessControlListEntryOutcomeCallable SlbClient::removeAccessControlListEntryCallable(const RemoveAccessControlListEntryRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RemoveAccessControlListEntryOutcome()>>(
+			[this, request]()
+			{
+			return this->removeAccessControlListEntry(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SlbClient::CreateDomainExtensionOutcome SlbClient::createDomainExtension(const CreateDomainExtensionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateDomainExtensionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateDomainExtensionOutcome(CreateDomainExtensionResult(outcome.result()));
+	else
+		return CreateDomainExtensionOutcome(outcome.error());
+}
+
+void SlbClient::createDomainExtensionAsync(const CreateDomainExtensionRequest& request, const CreateDomainExtensionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createDomainExtension(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SlbClient::CreateDomainExtensionOutcomeCallable SlbClient::createDomainExtensionCallable(const CreateDomainExtensionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateDomainExtensionOutcome()>>(
+			[this, request]()
+			{
+			return this->createDomainExtension(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SlbClient::DescribeRuleAttributeOutcome SlbClient::describeRuleAttribute(const DescribeRuleAttributeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2283,6 +2715,42 @@ SlbClient::ModifyLoadBalancerInternetSpecOutcomeCallable SlbClient::modifyLoadBa
 	return task->get_future();
 }
 
+SlbClient::CreateAccessControlListOutcome SlbClient::createAccessControlList(const CreateAccessControlListRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateAccessControlListOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateAccessControlListOutcome(CreateAccessControlListResult(outcome.result()));
+	else
+		return CreateAccessControlListOutcome(outcome.error());
+}
+
+void SlbClient::createAccessControlListAsync(const CreateAccessControlListRequest& request, const CreateAccessControlListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createAccessControlList(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SlbClient::CreateAccessControlListOutcomeCallable SlbClient::createAccessControlListCallable(const CreateAccessControlListRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateAccessControlListOutcome()>>(
+			[this, request]()
+			{
+			return this->createAccessControlList(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SlbClient::DescribeLoadBalancerHTTPSListenerAttributeOutcome SlbClient::describeLoadBalancerHTTPSListenerAttribute(const DescribeLoadBalancerHTTPSListenerAttributeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

slb/src/model/AddAccessControlListEntryRequest.cc

@@ -0,0 +1,137 @@
+/*
+ * 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/slb/model/AddAccessControlListEntryRequest.h>
+
+using AlibabaCloud::Slb::Model::AddAccessControlListEntryRequest;
+
+AddAccessControlListEntryRequest::AddAccessControlListEntryRequest() :
+	RpcServiceRequest("slb", "2014-05-15", "AddAccessControlListEntry")
+{}
+
+AddAccessControlListEntryRequest::~AddAccessControlListEntryRequest()
+{}
+
+std::string AddAccessControlListEntryRequest::getAccess_key_id()const
+{
+	return access_key_id_;
+}
+
+void AddAccessControlListEntryRequest::setAccess_key_id(const std::string& access_key_id)
+{
+	access_key_id_ = access_key_id;
+	setParameter("Access_key_id", access_key_id);
+}
+
+std::string AddAccessControlListEntryRequest::getAclId()const
+{
+	return aclId_;
+}
+
+void AddAccessControlListEntryRequest::setAclId(const std::string& aclId)
+{
+	aclId_ = aclId;
+	setParameter("AclId", aclId);
+}
+
+long AddAccessControlListEntryRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void AddAccessControlListEntryRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string AddAccessControlListEntryRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void AddAccessControlListEntryRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string AddAccessControlListEntryRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void AddAccessControlListEntryRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string AddAccessControlListEntryRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void AddAccessControlListEntryRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string AddAccessControlListEntryRequest::getAclEntrys()const
+{
+	return aclEntrys_;
+}
+
+void AddAccessControlListEntryRequest::setAclEntrys(const std::string& aclEntrys)
+{
+	aclEntrys_ = aclEntrys;
+	setParameter("AclEntrys", aclEntrys);
+}
+
+long AddAccessControlListEntryRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void AddAccessControlListEntryRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string AddAccessControlListEntryRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void AddAccessControlListEntryRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string AddAccessControlListEntryRequest::getTags()const
+{
+	return tags_;
+}
+
+void AddAccessControlListEntryRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+

slb/src/model/AddAccessControlListEntryResult.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/slb/model/AddAccessControlListEntryResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+AddAccessControlListEntryResult::AddAccessControlListEntryResult() :
+	ServiceResult()
+{}
+
+AddAccessControlListEntryResult::AddAccessControlListEntryResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AddAccessControlListEntryResult::~AddAccessControlListEntryResult()
+{}
+
+void AddAccessControlListEntryResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+
+}
+

slb/src/model/AddBackendServersResult.cc

@@ -40,28 +40,36 @@ void AddBackendServersResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allBackendServers = value["BackendServers"]["BackendServer"];
-	for (auto value : allBackendServers)
-	{
-		BackendServer backendServersObject;
-		if(!value["ServerId"].isNull())
-			backendServersObject.serverId = value["ServerId"].asString();
-		if(!value["Weight"].isNull())
-			backendServersObject.weight = value["Weight"].asString();
-		backendServers_.push_back(backendServersObject);
-	}
-	if(!value["LoadBalancerId"].isNull())
-		loadBalancerId_ = value["LoadBalancerId"].asString();
+	auto allBackendServers = value["BackendServers"]["BackendServer"];
+	for (auto value : allBackendServers)
+	{
+		BackendServer backendServersObject;
+		if(!value["ServerId"].isNull())
+			backendServersObject.serverId = value["ServerId"].asString();
+		if(!value["Weight"].isNull())
+			backendServersObject.weight = value["Weight"].asString();
+		if(!value["ServerIp"].isNull())
+			backendServersObject.serverIp = value["ServerIp"].asString();
+		if(!value["VpcId"].isNull())
+			backendServersObject.vpcId = value["VpcId"].asString();
+		if(!value["EniHost"].isNull())
+			backendServersObject.eniHost = value["EniHost"].asString();
+		if(!value["Type"].isNull())
+			backendServersObject.type = value["Type"].asString();
+		backendServers_.push_back(backendServersObject);
+	}
+	if(!value["LoadBalancerId"].isNull())
+		loadBalancerId_ = value["LoadBalancerId"].asString();
 
 }
 
-std::string AddBackendServersResult::getLoadBalancerId()const
-{
-	return loadBalancerId_;
-}
-
-std::vector<AddBackendServersResult::BackendServer> AddBackendServersResult::getBackendServers()const
-{
-	return backendServers_;
-}
-
+std::string AddBackendServersResult::getLoadBalancerId()const
+{
+	return loadBalancerId_;
+}
+
+std::vector<AddBackendServersResult::BackendServer> AddBackendServersResult::getBackendServers()const
+{
+	return backendServers_;
+}
+

slb/src/model/AddVServerGroupBackendServersResult.cc

@@ -40,30 +40,38 @@ void AddVServerGroupBackendServersResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allBackendServers = value["BackendServers"]["BackendServer"];
-	for (auto value : allBackendServers)
-	{
-		BackendServer backendServersObject;
-		if(!value["ServerId"].isNull())
-			backendServersObject.serverId = value["ServerId"].asString();
-		if(!value["Port"].isNull())
-			backendServersObject.port = std::stoi(value["Port"].asString());
-		if(!value["Weight"].isNull())
-			backendServersObject.weight = std::stoi(value["Weight"].asString());
-		backendServers_.push_back(backendServersObject);
-	}
-	if(!value["VServerGroupId"].isNull())
-		vServerGroupId_ = value["VServerGroupId"].asString();
+	auto allBackendServers = value["BackendServers"]["BackendServer"];
+	for (auto value : allBackendServers)
+	{
+		BackendServer backendServersObject;
+		if(!value["ServerId"].isNull())
+			backendServersObject.serverId = value["ServerId"].asString();
+		if(!value["Port"].isNull())
+			backendServersObject.port = std::stoi(value["Port"].asString());
+		if(!value["Weight"].isNull())
+			backendServersObject.weight = std::stoi(value["Weight"].asString());
+		if(!value["Type"].isNull())
+			backendServersObject.type = value["Type"].asString();
+		if(!value["ServerIp"].isNull())
+			backendServersObject.serverIp = value["ServerIp"].asString();
+		if(!value["EniHost"].isNull())
+			backendServersObject.eniHost = value["EniHost"].asString();
+		if(!value["VpcId"].isNull())
+			backendServersObject.vpcId = value["VpcId"].asString();
+		backendServers_.push_back(backendServersObject);
+	}
+	if(!value["VServerGroupId"].isNull())
+		vServerGroupId_ = value["VServerGroupId"].asString();
 
 }
 
-std::string AddVServerGroupBackendServersResult::getVServerGroupId()const
-{
-	return vServerGroupId_;
-}
-
-std::vector<AddVServerGroupBackendServersResult::BackendServer> AddVServerGroupBackendServersResult::getBackendServers()const
-{
-	return backendServers_;
-}
-
+std::string AddVServerGroupBackendServersResult::getVServerGroupId()const
+{
+	return vServerGroupId_;
+}
+
+std::vector<AddVServerGroupBackendServersResult::BackendServer> AddVServerGroupBackendServersResult::getBackendServers()const
+{
+	return backendServers_;
+}
+

slb/src/model/CreateAccessControlListRequest.cc

@@ -0,0 +1,137 @@
+/*
+ * 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/slb/model/CreateAccessControlListRequest.h>
+
+using AlibabaCloud::Slb::Model::CreateAccessControlListRequest;
+
+CreateAccessControlListRequest::CreateAccessControlListRequest() :
+	RpcServiceRequest("slb", "2014-05-15", "CreateAccessControlList")
+{}
+
+CreateAccessControlListRequest::~CreateAccessControlListRequest()
+{}
+
+std::string CreateAccessControlListRequest::getAccess_key_id()const
+{
+	return access_key_id_;
+}
+
+void CreateAccessControlListRequest::setAccess_key_id(const std::string& access_key_id)
+{
+	access_key_id_ = access_key_id;
+	setParameter("Access_key_id", access_key_id);
+}
+
+long CreateAccessControlListRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateAccessControlListRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string CreateAccessControlListRequest::getAclName()const
+{
+	return aclName_;
+}
+
+void CreateAccessControlListRequest::setAclName(const std::string& aclName)
+{
+	aclName_ = aclName;
+	setParameter("AclName", aclName);
+}
+
+std::string CreateAccessControlListRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateAccessControlListRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateAccessControlListRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateAccessControlListRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreateAccessControlListRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateAccessControlListRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long CreateAccessControlListRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateAccessControlListRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateAccessControlListRequest::getAddressIPVersion()const
+{
+	return addressIPVersion_;
+}
+
+void CreateAccessControlListRequest::setAddressIPVersion(const std::string& addressIPVersion)
+{
+	addressIPVersion_ = addressIPVersion;
+	setParameter("AddressIPVersion", addressIPVersion);
+}
+
+std::string CreateAccessControlListRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CreateAccessControlListRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string CreateAccessControlListRequest::getTags()const
+{
+	return tags_;
+}
+
+void CreateAccessControlListRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+

slb/src/model/CreateAccessControlListResult.cc

@@ -0,0 +1,52 @@
+/*
+ * 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/slb/model/CreateAccessControlListResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+CreateAccessControlListResult::CreateAccessControlListResult() :
+	ServiceResult()
+{}
+
+CreateAccessControlListResult::CreateAccessControlListResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateAccessControlListResult::~CreateAccessControlListResult()
+{}
+
+void CreateAccessControlListResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	if(!value["AclId"].isNull())
+		aclId_ = value["AclId"].asString();
+
+}
+
+std::string CreateAccessControlListResult::getAclId()const
+{
+	return aclId_;
+}
+

slb/src/model/CreateDomainExtensionRequest.cc

@@ -0,0 +1,148 @@
+/*
+ * 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/slb/model/CreateDomainExtensionRequest.h>
+
+using AlibabaCloud::Slb::Model::CreateDomainExtensionRequest;
+
+CreateDomainExtensionRequest::CreateDomainExtensionRequest() :
+	RpcServiceRequest("slb", "2014-05-15", "CreateDomainExtension")
+{}
+
+CreateDomainExtensionRequest::~CreateDomainExtensionRequest()
+{}
+
+std::string CreateDomainExtensionRequest::getAccess_key_id()const
+{
+	return access_key_id_;
+}
+
+void CreateDomainExtensionRequest::setAccess_key_id(const std::string& access_key_id)
+{
+	access_key_id_ = access_key_id;
+	setParameter("Access_key_id", access_key_id);
+}
+
+long CreateDomainExtensionRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateDomainExtensionRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+int CreateDomainExtensionRequest::getListenerPort()const
+{
+	return listenerPort_;
+}
+
+void CreateDomainExtensionRequest::setListenerPort(int listenerPort)
+{
+	listenerPort_ = listenerPort;
+	setParameter("ListenerPort", std::to_string(listenerPort));
+}
+
+std::string CreateDomainExtensionRequest::getLoadBalancerId()const
+{
+	return loadBalancerId_;
+}
+
+void CreateDomainExtensionRequest::setLoadBalancerId(const std::string& loadBalancerId)
+{
+	loadBalancerId_ = loadBalancerId;
+	setParameter("LoadBalancerId", loadBalancerId);
+}
+
+std::string CreateDomainExtensionRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateDomainExtensionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateDomainExtensionRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateDomainExtensionRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreateDomainExtensionRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateDomainExtensionRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string CreateDomainExtensionRequest::getDomain()const
+{
+	return domain_;
+}
+
+void CreateDomainExtensionRequest::setDomain(const std::string& domain)
+{
+	domain_ = domain;
+	setParameter("Domain", domain);
+}
+
+long CreateDomainExtensionRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateDomainExtensionRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateDomainExtensionRequest::getServerCertificateId()const
+{
+	return serverCertificateId_;
+}
+
+void CreateDomainExtensionRequest::setServerCertificateId(const std::string& serverCertificateId)
+{
+	serverCertificateId_ = serverCertificateId;
+	setParameter("ServerCertificateId", serverCertificateId);
+}
+
+std::string CreateDomainExtensionRequest::getTags()const
+{
+	return tags_;
+}
+
+void CreateDomainExtensionRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+

slb/src/model/CreateDomainExtensionResult.cc

@@ -0,0 +1,59 @@
+/*
+ * 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/slb/model/CreateDomainExtensionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+CreateDomainExtensionResult::CreateDomainExtensionResult() :
+	ServiceResult()
+{}
+
+CreateDomainExtensionResult::CreateDomainExtensionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateDomainExtensionResult::~CreateDomainExtensionResult()
+{}
+
+void CreateDomainExtensionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	if(!value["ListenerPort"].isNull())
+		listenerPort_ = std::stoi(value["ListenerPort"].asString());
+	if(!value["DomainExtensionId"].isNull())
+		domainExtensionId_ = value["DomainExtensionId"].asString();
+
+}
+
+int CreateDomainExtensionResult::getListenerPort()const
+{
+	return listenerPort_;
+}
+
+std::string CreateDomainExtensionResult::getDomainExtensionId()const
+{
+	return domainExtensionId_;
+}
+

slb/src/model/CreateLoadBalancerHTTPListenerRequest.cc

@@ -58,6 +58,17 @@ void CreateLoadBalancerHTTPListenerRequest::setHealthCheckTimeout(int healthChec
 	setParameter("HealthCheckTimeout", std::to_string(healthCheckTimeout));
 }
 
+std::string CreateLoadBalancerHTTPListenerRequest::getListenerForward()const
+{
+	return listenerForward_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setListenerForward(const std::string& listenerForward)
+{
+	listenerForward_ = listenerForward;
+	setParameter("ListenerForward", listenerForward);
+}
+
 std::string CreateLoadBalancerHTTPListenerRequest::getXForwardedFor()const
 {
 	return xForwardedFor_;
@@ -80,6 +91,17 @@ void CreateLoadBalancerHTTPListenerRequest::setHealthCheckURI(const std::string&
 	setParameter("HealthCheckURI", healthCheckURI);
 }
 
+std::string CreateLoadBalancerHTTPListenerRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
 int CreateLoadBalancerHTTPListenerRequest::getUnhealthyThreshold()const
 {
 	return unhealthyThreshold_;
@@ -102,6 +124,17 @@ void CreateLoadBalancerHTTPListenerRequest::setHealthyThreshold(int healthyThres
 	setParameter("HealthyThreshold", std::to_string(healthyThreshold));
 }
 
+std::string CreateLoadBalancerHTTPListenerRequest::getAclStatus()const
+{
+	return aclStatus_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setAclStatus(const std::string& aclStatus)
+{
+	aclStatus_ = aclStatus;
+	setParameter("AclStatus", aclStatus);
+}
+
 std::string CreateLoadBalancerHTTPListenerRequest::getScheduler()const
 {
 	return scheduler_;
@@ -113,6 +146,17 @@ void CreateLoadBalancerHTTPListenerRequest::setScheduler(const std::string& sche
 	setParameter("Scheduler", scheduler);
 }
 
+std::string CreateLoadBalancerHTTPListenerRequest::getAclType()const
+{
+	return aclType_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setAclType(const std::string& aclType)
+{
+	aclType_ = aclType;
+	setParameter("AclType", aclType);
+}
+
 std::string CreateLoadBalancerHTTPListenerRequest::getHealthCheck()const
 {
 	return healthCheck_;
@@ -124,6 +168,17 @@ void CreateLoadBalancerHTTPListenerRequest::setHealthCheck(const std::string& he
 	setParameter("HealthCheck", healthCheck);
 }
 
+int CreateLoadBalancerHTTPListenerRequest::getForwardPort()const
+{
+	return forwardPort_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setForwardPort(int forwardPort)
+{
+	forwardPort_ = forwardPort;
+	setParameter("ForwardPort", std::to_string(forwardPort));
+}
+
 int CreateLoadBalancerHTTPListenerRequest::getMaxConnection()const
 {
 	return maxConnection_;
@@ -168,6 +223,17 @@ void CreateLoadBalancerHTTPListenerRequest::setStickySessionType(const std::stri
 	setParameter("StickySessionType", stickySessionType);
 }
 
+std::string CreateLoadBalancerHTTPListenerRequest::getVpcIds()const
+{
+	return vpcIds_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setVpcIds(const std::string& vpcIds)
+{
+	vpcIds_ = vpcIds;
+	setParameter("VpcIds", vpcIds);
+}
+
 std::string CreateLoadBalancerHTTPListenerRequest::getVServerGroupId()const
 {
 	return vServerGroupId_;
@@ -179,6 +245,17 @@ void CreateLoadBalancerHTTPListenerRequest::setVServerGroupId(const std::string&
 	setParameter("VServerGroupId", vServerGroupId);
 }
 
+std::string CreateLoadBalancerHTTPListenerRequest::getAclId()const
+{
+	return aclId_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setAclId(const std::string& aclId)
+{
+	aclId_ = aclId;
+	setParameter("AclId", aclId);
+}
+
 int CreateLoadBalancerHTTPListenerRequest::getListenerPort()const
 {
 	return listenerPort_;
@@ -245,6 +322,17 @@ void CreateLoadBalancerHTTPListenerRequest::setHealthCheckDomain(const std::stri
 	setParameter("HealthCheckDomain", healthCheckDomain);
 }
 
+int CreateLoadBalancerHTTPListenerRequest::getRequestTimeout()const
+{
+	return requestTimeout_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setRequestTimeout(int requestTimeout)
+{
+	requestTimeout_ = requestTimeout;
+	setParameter("RequestTimeout", std::to_string(requestTimeout));
+}
+
 std::string CreateLoadBalancerHTTPListenerRequest::getOwnerAccount()const
 {
 	return ownerAccount_;
@@ -289,6 +377,17 @@ void CreateLoadBalancerHTTPListenerRequest::setTags(const std::string& tags)
 	setParameter("Tags", tags);
 }
 
+int CreateLoadBalancerHTTPListenerRequest::getIdleTimeout()const
+{
+	return idleTimeout_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setIdleTimeout(int idleTimeout)
+{
+	idleTimeout_ = idleTimeout;
+	setParameter("IdleTimeout", std::to_string(idleTimeout));
+}
+
 std::string CreateLoadBalancerHTTPListenerRequest::getLoadBalancerId()const
 {
 	return loadBalancerId_;

slb/src/model/CreateLoadBalancerHTTPSListenerRequest.cc

@@ -80,6 +80,17 @@ void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckURI(const std::string
 	setParameter("HealthCheckURI", healthCheckURI);
 }
 
+std::string CreateLoadBalancerHTTPSListenerRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
 int CreateLoadBalancerHTTPSListenerRequest::getUnhealthyThreshold()const
 {
 	return unhealthyThreshold_;
@@ -102,6 +113,17 @@ void CreateLoadBalancerHTTPSListenerRequest::setHealthyThreshold(int healthyThre
 	setParameter("HealthyThreshold", std::to_string(healthyThreshold));
 }
 
+std::string CreateLoadBalancerHTTPSListenerRequest::getAclStatus()const
+{
+	return aclStatus_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setAclStatus(const std::string& aclStatus)
+{
+	aclStatus_ = aclStatus;
+	setParameter("AclStatus", aclStatus);
+}
+
 std::string CreateLoadBalancerHTTPSListenerRequest::getScheduler()const
 {
 	return scheduler_;
@@ -113,6 +135,17 @@ void CreateLoadBalancerHTTPSListenerRequest::setScheduler(const std::string& sch
 	setParameter("Scheduler", scheduler);
 }
 
+std::string CreateLoadBalancerHTTPSListenerRequest::getAclType()const
+{
+	return aclType_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setAclType(const std::string& aclType)
+{
+	aclType_ = aclType;
+	setParameter("AclType", aclType);
+}
+
 std::string CreateLoadBalancerHTTPSListenerRequest::getHealthCheck()const
 {
 	return healthCheck_;
@@ -135,6 +168,17 @@ void CreateLoadBalancerHTTPSListenerRequest::setMaxConnection(int maxConnection)
 	setParameter("MaxConnection", std::to_string(maxConnection));
 }
 
+std::string CreateLoadBalancerHTTPSListenerRequest::getEnableHttp2()const
+{
+	return enableHttp2_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setEnableHttp2(const std::string& enableHttp2)
+{
+	enableHttp2_ = enableHttp2;
+	setParameter("EnableHttp2", enableHttp2);
+}
+
 std::string CreateLoadBalancerHTTPSListenerRequest::getRegionId()const
 {
 	return regionId_;
@@ -168,6 +212,17 @@ void CreateLoadBalancerHTTPSListenerRequest::setStickySessionType(const std::str
 	setParameter("StickySessionType", stickySessionType);
 }
 
+std::string CreateLoadBalancerHTTPSListenerRequest::getVpcIds()const
+{
+	return vpcIds_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setVpcIds(const std::string& vpcIds)
+{
+	vpcIds_ = vpcIds;
+	setParameter("VpcIds", vpcIds);
+}
+
 std::string CreateLoadBalancerHTTPSListenerRequest::getVServerGroupId()const
 {
 	return vServerGroupId_;
@@ -179,6 +234,17 @@ void CreateLoadBalancerHTTPSListenerRequest::setVServerGroupId(const std::string
 	setParameter("VServerGroupId", vServerGroupId);
 }
 
+std::string CreateLoadBalancerHTTPSListenerRequest::getAclId()const
+{
+	return aclId_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setAclId(const std::string& aclId)
+{
+	aclId_ = aclId;
+	setParameter("AclId", aclId);
+}
+
 int CreateLoadBalancerHTTPSListenerRequest::getListenerPort()const
 {
 	return listenerPort_;
@@ -245,6 +311,17 @@ void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckDomain(const std::str
 	setParameter("HealthCheckDomain", healthCheckDomain);
 }
 
+int CreateLoadBalancerHTTPSListenerRequest::getRequestTimeout()const
+{
+	return requestTimeout_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setRequestTimeout(int requestTimeout)
+{
+	requestTimeout_ = requestTimeout;
+	setParameter("RequestTimeout", std::to_string(requestTimeout));
+}
+
 std::string CreateLoadBalancerHTTPSListenerRequest::getOwnerAccount()const
 {
 	return ownerAccount_;
@@ -267,6 +344,17 @@ void CreateLoadBalancerHTTPSListenerRequest::setGzip(const std::string& gzip)
 	setParameter("Gzip", gzip);
 }
 
+std::string CreateLoadBalancerHTTPSListenerRequest::getTLSCipherPolicy()const
+{
+	return tLSCipherPolicy_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setTLSCipherPolicy(const std::string& tLSCipherPolicy)
+{
+	tLSCipherPolicy_ = tLSCipherPolicy;
+	setParameter("TLSCipherPolicy", tLSCipherPolicy);
+}
+
 long CreateLoadBalancerHTTPSListenerRequest::getOwnerId()const
 {
 	return ownerId_;
@@ -311,6 +399,17 @@ void CreateLoadBalancerHTTPSListenerRequest::setTags(const std::string& tags)
 	setParameter("Tags", tags);
 }
 
+int CreateLoadBalancerHTTPSListenerRequest::getIdleTimeout()const
+{
+	return idleTimeout_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setIdleTimeout(int idleTimeout)
+{
+	idleTimeout_ = idleTimeout;
+	setParameter("IdleTimeout", std::to_string(idleTimeout));
+}
+
 std::string CreateLoadBalancerHTTPSListenerRequest::getLoadBalancerId()const
 {
 	return loadBalancerId_;

slb/src/model/CreateLoadBalancerRequest.cc

@@ -36,17 +36,6 @@ void CreateLoadBalancerRequest::setAccess_key_id(const std::string& access_key_i
 	setParameter("Access_key_id", access_key_id);
 }
 
-std::string CreateLoadBalancerRequest::getLoadBalancerSpec()const
-{
-	return loadBalancerSpec_;
-}
-
-void CreateLoadBalancerRequest::setLoadBalancerSpec(const std::string& loadBalancerSpec)
-{
-	loadBalancerSpec_ = loadBalancerSpec;
-	setParameter("LoadBalancerSpec", loadBalancerSpec);
-}
-
 long CreateLoadBalancerRequest::getResourceOwnerId()const
 {
 	return resourceOwnerId_;
@@ -58,39 +47,6 @@ void CreateLoadBalancerRequest::setResourceOwnerId(long resourceOwnerId)
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
-bool CreateLoadBalancerRequest::getAutoPay()const
-{
-	return autoPay_;
-}
-
-void CreateLoadBalancerRequest::setAutoPay(bool autoPay)
-{
-	autoPay_ = autoPay;
-	setParameter("AutoPay", std::to_string(autoPay));
-}
-
-std::string CreateLoadBalancerRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
-}
-
-void CreateLoadBalancerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
-}
-
-int CreateLoadBalancerRequest::getBandwidth()const
-{
-	return bandwidth_;
-}
-
-void CreateLoadBalancerRequest::setBandwidth(int bandwidth)
-{
-	bandwidth_ = bandwidth;
-	setParameter("Bandwidth", std::to_string(bandwidth));
-}
-
 std::string CreateLoadBalancerRequest::getClientToken()const
 {
 	return clientToken_;
@@ -102,26 +58,15 @@ void CreateLoadBalancerRequest::setClientToken(const std::string& clientToken)
 	setParameter("ClientToken", clientToken);
 }
 
-std::string CreateLoadBalancerRequest::getOwnerAccount()const
+std::string CreateLoadBalancerRequest::getAddressIPVersion()const
 {
-	return ownerAccount_;
+	return addressIPVersion_;
 }
 
-void CreateLoadBalancerRequest::setOwnerAccount(const std::string& ownerAccount)
+void CreateLoadBalancerRequest::setAddressIPVersion(const std::string& addressIPVersion)
 {
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
-}
-
-long CreateLoadBalancerRequest::getOwnerId()const
-{
-	return ownerId_;
-}
-
-void CreateLoadBalancerRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	addressIPVersion_ = addressIPVersion;
+	setParameter("AddressIPVersion", addressIPVersion);
 }
 
 std::string CreateLoadBalancerRequest::getMasterZoneId()const
@@ -135,28 +80,6 @@ void CreateLoadBalancerRequest::setMasterZoneId(const std::string& masterZoneId)
 	setParameter("MasterZoneId", masterZoneId);
 }
 
-std::string CreateLoadBalancerRequest::getTags()const
-{
-	return tags_;
-}
-
-void CreateLoadBalancerRequest::setTags(const std::string& tags)
-{
-	tags_ = tags;
-	setParameter("Tags", tags);
-}
-
-std::string CreateLoadBalancerRequest::getVSwitchId()const
-{
-	return vSwitchId_;
-}
-
-void CreateLoadBalancerRequest::setVSwitchId(const std::string& vSwitchId)
-{
-	vSwitchId_ = vSwitchId;
-	setParameter("VSwitchId", vSwitchId);
-}
-
 int CreateLoadBalancerRequest::getDuration()const
 {
 	return duration_;
@@ -190,17 +113,6 @@ void CreateLoadBalancerRequest::setLoadBalancerName(const std::string& loadBalan
 	setParameter("LoadBalancerName", loadBalancerName);
 }
 
-std::string CreateLoadBalancerRequest::getEnableVpcVipFlow()const
-{
-	return enableVpcVipFlow_;
-}
-
-void CreateLoadBalancerRequest::setEnableVpcVipFlow(const std::string& enableVpcVipFlow)
-{
-	enableVpcVipFlow_ = enableVpcVipFlow;
-	setParameter("EnableVpcVipFlow", enableVpcVipFlow);
-}
-
 std::string CreateLoadBalancerRequest::getRegionId()const
 {
 	return regionId_;
@@ -212,28 +124,6 @@ void CreateLoadBalancerRequest::setRegionId(const std::string& regionId)
 	setParameter("RegionId", regionId);
 }
 
-std::string CreateLoadBalancerRequest::getInternetChargeType()const
-{
-	return internetChargeType_;
-}
-
-void CreateLoadBalancerRequest::setInternetChargeType(const std::string& internetChargeType)
-{
-	internetChargeType_ = internetChargeType;
-	setParameter("InternetChargeType", internetChargeType);
-}
-
-std::string CreateLoadBalancerRequest::getVpcId()const
-{
-	return vpcId_;
-}
-
-void CreateLoadBalancerRequest::setVpcId(const std::string& vpcId)
-{
-	vpcId_ = vpcId;
-	setParameter("VpcId", vpcId);
-}
-
 std::string CreateLoadBalancerRequest::getAddressType()const
 {
 	return addressType_;
@@ -256,6 +146,127 @@ void CreateLoadBalancerRequest::setSlaveZoneId(const std::string& slaveZoneId)
 	setParameter("SlaveZoneId", slaveZoneId);
 }
 
+std::string CreateLoadBalancerRequest::getLoadBalancerSpec()const
+{
+	return loadBalancerSpec_;
+}
+
+void CreateLoadBalancerRequest::setLoadBalancerSpec(const std::string& loadBalancerSpec)
+{
+	loadBalancerSpec_ = loadBalancerSpec;
+	setParameter("LoadBalancerSpec", loadBalancerSpec);
+}
+
+bool CreateLoadBalancerRequest::getAutoPay()const
+{
+	return autoPay_;
+}
+
+void CreateLoadBalancerRequest::setAutoPay(bool autoPay)
+{
+	autoPay_ = autoPay;
+	setParameter("AutoPay", std::to_string(autoPay));
+}
+
+std::string CreateLoadBalancerRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateLoadBalancerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+int CreateLoadBalancerRequest::getBandwidth()const
+{
+	return bandwidth_;
+}
+
+void CreateLoadBalancerRequest::setBandwidth(int bandwidth)
+{
+	bandwidth_ = bandwidth;
+	setParameter("Bandwidth", std::to_string(bandwidth));
+}
+
+std::string CreateLoadBalancerRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateLoadBalancerRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long CreateLoadBalancerRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateLoadBalancerRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateLoadBalancerRequest::getTags()const
+{
+	return tags_;
+}
+
+void CreateLoadBalancerRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+
+std::string CreateLoadBalancerRequest::getVSwitchId()const
+{
+	return vSwitchId_;
+}
+
+void CreateLoadBalancerRequest::setVSwitchId(const std::string& vSwitchId)
+{
+	vSwitchId_ = vSwitchId;
+	setParameter("VSwitchId", vSwitchId);
+}
+
+std::string CreateLoadBalancerRequest::getEnableVpcVipFlow()const
+{
+	return enableVpcVipFlow_;
+}
+
+void CreateLoadBalancerRequest::setEnableVpcVipFlow(const std::string& enableVpcVipFlow)
+{
+	enableVpcVipFlow_ = enableVpcVipFlow;
+	setParameter("EnableVpcVipFlow", enableVpcVipFlow);
+}
+
+std::string CreateLoadBalancerRequest::getInternetChargeType()const
+{
+	return internetChargeType_;
+}
+
+void CreateLoadBalancerRequest::setInternetChargeType(const std::string& internetChargeType)
+{
+	internetChargeType_ = internetChargeType;
+	setParameter("InternetChargeType", internetChargeType);
+}
+
+std::string CreateLoadBalancerRequest::getVpcId()const
+{
+	return vpcId_;
+}
+
+void CreateLoadBalancerRequest::setVpcId(const std::string& vpcId)
+{
+	vpcId_ = vpcId;
+	setParameter("VpcId", vpcId);
+}
+
 std::string CreateLoadBalancerRequest::getPayType()const
 {
 	return payType_;

slb/src/model/CreateLoadBalancerResult.cc

@@ -40,62 +40,69 @@ void CreateLoadBalancerResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["LoadBalancerId"].isNull())
-		loadBalancerId_ = value["LoadBalancerId"].asString();
-	if(!value["ResourceGroupId"].isNull())
-		resourceGroupId_ = value["ResourceGroupId"].asString();
-	if(!value["Address"].isNull())
-		address_ = value["Address"].asString();
-	if(!value["LoadBalancerName"].isNull())
-		loadBalancerName_ = value["LoadBalancerName"].asString();
-	if(!value["VpcId"].isNull())
-		vpcId_ = value["VpcId"].asString();
-	if(!value["VSwitchId"].isNull())
-		vSwitchId_ = value["VSwitchId"].asString();
-	if(!value["NetworkType"].isNull())
-		networkType_ = value["NetworkType"].asString();
-	if(!value["OrderId"].isNull())
-		orderId_ = std::stol(value["OrderId"].asString());
+	if(!value["LoadBalancerId"].isNull())
+		loadBalancerId_ = value["LoadBalancerId"].asString();
+	if(!value["ResourceGroupId"].isNull())
+		resourceGroupId_ = value["ResourceGroupId"].asString();
+	if(!value["Address"].isNull())
+		address_ = value["Address"].asString();
+	if(!value["LoadBalancerName"].isNull())
+		loadBalancerName_ = value["LoadBalancerName"].asString();
+	if(!value["VpcId"].isNull())
+		vpcId_ = value["VpcId"].asString();
+	if(!value["VSwitchId"].isNull())
+		vSwitchId_ = value["VSwitchId"].asString();
+	if(!value["NetworkType"].isNull())
+		networkType_ = value["NetworkType"].asString();
+	if(!value["OrderId"].isNull())
+		orderId_ = std::stol(value["OrderId"].asString());
+	if(!value["AddressIPVersion"].isNull())
+		addressIPVersion_ = value["AddressIPVersion"].asString();
 
 }
 
-std::string CreateLoadBalancerResult::getLoadBalancerName()const
-{
-	return loadBalancerName_;
-}
-
-std::string CreateLoadBalancerResult::getResourceGroupId()const
-{
-	return resourceGroupId_;
-}
-
-std::string CreateLoadBalancerResult::getAddress()const
-{
-	return address_;
-}
-
-std::string CreateLoadBalancerResult::getVpcId()const
-{
-	return vpcId_;
-}
-
-std::string CreateLoadBalancerResult::getNetworkType()const
-{
-	return networkType_;
-}
-
-std::string CreateLoadBalancerResult::getVSwitchId()const
-{
-	return vSwitchId_;
-}
-
-std::string CreateLoadBalancerResult::getLoadBalancerId()const
-{
-	return loadBalancerId_;
-}
-
-long CreateLoadBalancerResult::getOrderId()const
-{
-	return orderId_;
-}
-
+std::string CreateLoadBalancerResult::getLoadBalancerName()const
+{
+	return loadBalancerName_;
+}
+
+std::string CreateLoadBalancerResult::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+std::string CreateLoadBalancerResult::getAddress()const
+{
+	return address_;
+}
+
+std::string CreateLoadBalancerResult::getVpcId()const
+{
+	return vpcId_;
+}
+
+std::string CreateLoadBalancerResult::getNetworkType()const
+{
+	return networkType_;
+}
+
+std::string CreateLoadBalancerResult::getVSwitchId()const
+{
+	return vSwitchId_;
+}
+
+std::string CreateLoadBalancerResult::getAddressIPVersion()const
+{
+	return addressIPVersion_;
+}
+
+std::string CreateLoadBalancerResult::getLoadBalancerId()const
+{
+	return loadBalancerId_;
+}
+
+long CreateLoadBalancerResult::getOrderId()const
+{
+	return orderId_;
+}
+

slb/src/model/CreateLoadBalancerTCPListenerRequest.cc

@@ -69,6 +69,17 @@ void CreateLoadBalancerTCPListenerRequest::setHealthCheckURI(const std::string&
 	setParameter("HealthCheckURI", healthCheckURI);
 }
 
+std::string CreateLoadBalancerTCPListenerRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
 int CreateLoadBalancerTCPListenerRequest::getUnhealthyThreshold()const
 {
 	return unhealthyThreshold_;
@@ -91,6 +102,17 @@ void CreateLoadBalancerTCPListenerRequest::setHealthyThreshold(int healthyThresh
 	setParameter("HealthyThreshold", std::to_string(healthyThreshold));
 }
 
+std::string CreateLoadBalancerTCPListenerRequest::getAclStatus()const
+{
+	return aclStatus_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setAclStatus(const std::string& aclStatus)
+{
+	aclStatus_ = aclStatus;
+	setParameter("AclStatus", aclStatus);
+}
+
 std::string CreateLoadBalancerTCPListenerRequest::getScheduler()const
 {
 	return scheduler_;
@@ -102,6 +124,17 @@ void CreateLoadBalancerTCPListenerRequest::setScheduler(const std::string& sched
 	setParameter("Scheduler", scheduler);
 }
 
+std::string CreateLoadBalancerTCPListenerRequest::getAclType()const
+{
+	return aclType_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setAclType(const std::string& aclType)
+{
+	aclType_ = aclType;
+	setParameter("AclType", aclType);
+}
+
 int CreateLoadBalancerTCPListenerRequest::getEstablishedTimeout()const
 {
 	return establishedTimeout_;
@@ -146,6 +179,17 @@ void CreateLoadBalancerTCPListenerRequest::setPersistenceTimeout(int persistence
 	setParameter("PersistenceTimeout", std::to_string(persistenceTimeout));
 }
 
+std::string CreateLoadBalancerTCPListenerRequest::getVpcIds()const
+{
+	return vpcIds_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setVpcIds(const std::string& vpcIds)
+{
+	vpcIds_ = vpcIds;
+	setParameter("VpcIds", vpcIds);
+}
+
 std::string CreateLoadBalancerTCPListenerRequest::getVServerGroupId()const
 {
 	return vServerGroupId_;
@@ -157,6 +201,17 @@ void CreateLoadBalancerTCPListenerRequest::setVServerGroupId(const std::string&
 	setParameter("VServerGroupId", vServerGroupId);
 }
 
+std::string CreateLoadBalancerTCPListenerRequest::getAclId()const
+{
+	return aclId_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setAclId(const std::string& aclId)
+{
+	aclId_ = aclId;
+	setParameter("AclId", aclId);
+}
+
 int CreateLoadBalancerTCPListenerRequest::getListenerPort()const
 {
 	return listenerPort_;

slb/src/model/CreateLoadBalancerUDPListenerRequest.cc

@@ -36,17 +36,6 @@ void CreateLoadBalancerUDPListenerRequest::setAccess_key_id(const std::string& a
 	setParameter("Access_key_id", access_key_id);
 }
 
-std::string CreateLoadBalancerUDPListenerRequest::getVServerGroupId()const
-{
-	return vServerGroupId_;
-}
-
-void CreateLoadBalancerUDPListenerRequest::setVServerGroupId(const std::string& vServerGroupId)
-{
-	vServerGroupId_ = vServerGroupId;
-	setParameter("VServerGroupId", vServerGroupId);
-}
-
 int CreateLoadBalancerUDPListenerRequest::getHealthCheckConnectTimeout()const
 {
 	return healthCheckConnectTimeout_;
@@ -69,6 +58,138 @@ void CreateLoadBalancerUDPListenerRequest::setResourceOwnerId(long resourceOwner
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+std::string CreateLoadBalancerUDPListenerRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+int CreateLoadBalancerUDPListenerRequest::getUnhealthyThreshold()const
+{
+	return unhealthyThreshold_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setUnhealthyThreshold(int unhealthyThreshold)
+{
+	unhealthyThreshold_ = unhealthyThreshold;
+	setParameter("UnhealthyThreshold", std::to_string(unhealthyThreshold));
+}
+
+int CreateLoadBalancerUDPListenerRequest::getHealthyThreshold()const
+{
+	return healthyThreshold_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setHealthyThreshold(int healthyThreshold)
+{
+	healthyThreshold_ = healthyThreshold;
+	setParameter("HealthyThreshold", std::to_string(healthyThreshold));
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getAclStatus()const
+{
+	return aclStatus_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setAclStatus(const std::string& aclStatus)
+{
+	aclStatus_ = aclStatus;
+	setParameter("AclStatus", aclStatus);
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getScheduler()const
+{
+	return scheduler_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setScheduler(const std::string& scheduler)
+{
+	scheduler_ = scheduler;
+	setParameter("Scheduler", scheduler);
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getAclType()const
+{
+	return aclType_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setAclType(const std::string& aclType)
+{
+	aclType_ = aclType;
+	setParameter("AclType", aclType);
+}
+
+int CreateLoadBalancerUDPListenerRequest::getMaxConnection()const
+{
+	return maxConnection_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setMaxConnection(int maxConnection)
+{
+	maxConnection_ = maxConnection;
+	setParameter("MaxConnection", std::to_string(maxConnection));
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+int CreateLoadBalancerUDPListenerRequest::getPersistenceTimeout()const
+{
+	return persistenceTimeout_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setPersistenceTimeout(int persistenceTimeout)
+{
+	persistenceTimeout_ = persistenceTimeout;
+	setParameter("PersistenceTimeout", std::to_string(persistenceTimeout));
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getVpcIds()const
+{
+	return vpcIds_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setVpcIds(const std::string& vpcIds)
+{
+	vpcIds_ = vpcIds;
+	setParameter("VpcIds", vpcIds);
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getVServerGroupId()const
+{
+	return vServerGroupId_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setVServerGroupId(const std::string& vServerGroupId)
+{
+	vServerGroupId_ = vServerGroupId;
+	setParameter("VServerGroupId", vServerGroupId);
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getAclId()const
+{
+	return aclId_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setAclId(const std::string& aclId)
+{
+	aclId_ = aclId;
+	setParameter("AclId", aclId);
+}
+
 int CreateLoadBalancerUDPListenerRequest::getListenerPort()const
 {
 	return listenerPort_;
@@ -113,17 +234,6 @@ void CreateLoadBalancerUDPListenerRequest::setOwnerAccount(const std::string& ow
 	setParameter("OwnerAccount", ownerAccount);
 }
 
-int CreateLoadBalancerUDPListenerRequest::getUnhealthyThreshold()const
-{
-	return unhealthyThreshold_;
-}
-
-void CreateLoadBalancerUDPListenerRequest::setUnhealthyThreshold(int unhealthyThreshold)
-{
-	unhealthyThreshold_ = unhealthyThreshold;
-	setParameter("UnhealthyThreshold", std::to_string(unhealthyThreshold));
-}
-
 long CreateLoadBalancerUDPListenerRequest::getOwnerId()const
 {
 	return ownerId_;
@@ -135,17 +245,6 @@ void CreateLoadBalancerUDPListenerRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
-int CreateLoadBalancerUDPListenerRequest::getHealthyThreshold()const
-{
-	return healthyThreshold_;
-}
-
-void CreateLoadBalancerUDPListenerRequest::setHealthyThreshold(int healthyThreshold)
-{
-	healthyThreshold_ = healthyThreshold;
-	setParameter("HealthyThreshold", std::to_string(healthyThreshold));
-}
-
 std::string CreateLoadBalancerUDPListenerRequest::getTags()const
 {
 	return tags_;
@@ -157,17 +256,6 @@ void CreateLoadBalancerUDPListenerRequest::setTags(const std::string& tags)
 	setParameter("Tags", tags);
 }
 
-std::string CreateLoadBalancerUDPListenerRequest::getScheduler()const
-{
-	return scheduler_;
-}
-
-void CreateLoadBalancerUDPListenerRequest::setScheduler(const std::string& scheduler)
-{
-	scheduler_ = scheduler;
-	setParameter("Scheduler", scheduler);
-}
-
 std::string CreateLoadBalancerUDPListenerRequest::getLoadBalancerId()const
 {
 	return loadBalancerId_;
@@ -179,17 +267,6 @@ void CreateLoadBalancerUDPListenerRequest::setLoadBalancerId(const std::string&
 	setParameter("LoadBalancerId", loadBalancerId);
 }
 
-int CreateLoadBalancerUDPListenerRequest::getMaxConnection()const
-{
-	return maxConnection_;
-}
-
-void CreateLoadBalancerUDPListenerRequest::setMaxConnection(int maxConnection)
-{
-	maxConnection_ = maxConnection;
-	setParameter("MaxConnection", std::to_string(maxConnection));
-}
-
 std::string CreateLoadBalancerUDPListenerRequest::getMasterSlaveServerGroupId()const
 {
 	return masterSlaveServerGroupId_;
@@ -212,17 +289,6 @@ void CreateLoadBalancerUDPListenerRequest::setHealthCheckReq(const std::string&
 	setParameter("HealthCheckReq", healthCheckReq);
 }
 
-std::string CreateLoadBalancerUDPListenerRequest::getRegionId()const
-{
-	return regionId_;
-}
-
-void CreateLoadBalancerUDPListenerRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
-}
-
 int CreateLoadBalancerUDPListenerRequest::getBackendServerPort()const
 {
 	return backendServerPort_;
@@ -245,17 +311,6 @@ void CreateLoadBalancerUDPListenerRequest::setHealthCheckInterval(int healthChec
 	setParameter("HealthCheckInterval", std::to_string(healthCheckInterval));
 }
 
-int CreateLoadBalancerUDPListenerRequest::getPersistenceTimeout()const
-{
-	return persistenceTimeout_;
-}
-
-void CreateLoadBalancerUDPListenerRequest::setPersistenceTimeout(int persistenceTimeout)
-{
-	persistenceTimeout_ = persistenceTimeout;
-	setParameter("PersistenceTimeout", std::to_string(persistenceTimeout));
-}
-
 std::string CreateLoadBalancerUDPListenerRequest::getHealthCheckExp()const
 {
 	return healthCheckExp_;

slb/src/model/CreateMasterSlaveServerGroupResult.cc

@@ -40,32 +40,40 @@ void CreateMasterSlaveServerGroupResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allMasterSlaveBackendServers = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
-	for (auto value : allMasterSlaveBackendServers)
-	{
-		MasterSlaveBackendServer masterSlaveBackendServersObject;
-		if(!value["ServerId"].isNull())
-			masterSlaveBackendServersObject.serverId = value["ServerId"].asString();
-		if(!value["Port"].isNull())
-			masterSlaveBackendServersObject.port = std::stoi(value["Port"].asString());
-		if(!value["Weight"].isNull())
-			masterSlaveBackendServersObject.weight = std::stoi(value["Weight"].asString());
-		if(!value["ServerType"].isNull())
-			masterSlaveBackendServersObject.serverType = value["ServerType"].asString();
-		masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
-	}
-	if(!value["MasterSlaveServerGroupId"].isNull())
-		masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
+	auto allMasterSlaveBackendServers = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
+	for (auto value : allMasterSlaveBackendServers)
+	{
+		MasterSlaveBackendServer masterSlaveBackendServersObject;
+		if(!value["ServerId"].isNull())
+			masterSlaveBackendServersObject.serverId = value["ServerId"].asString();
+		if(!value["Port"].isNull())
+			masterSlaveBackendServersObject.port = std::stoi(value["Port"].asString());
+		if(!value["Weight"].isNull())
+			masterSlaveBackendServersObject.weight = std::stoi(value["Weight"].asString());
+		if(!value["ServerType"].isNull())
+			masterSlaveBackendServersObject.serverType = value["ServerType"].asString();
+		if(!value["Type"].isNull())
+			masterSlaveBackendServersObject.type = value["Type"].asString();
+		if(!value["ServerIp"].isNull())
+			masterSlaveBackendServersObject.serverIp = value["ServerIp"].asString();
+		if(!value["EniHost"].isNull())
+			masterSlaveBackendServersObject.eniHost = value["EniHost"].asString();
+		if(!value["VpcId"].isNull())
+			masterSlaveBackendServersObject.vpcId = value["VpcId"].asString();
+		masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
+	}
+	if(!value["MasterSlaveServerGroupId"].isNull())
+		masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
 
 }
 
-std::string CreateMasterSlaveServerGroupResult::getMasterSlaveServerGroupId()const
-{
-	return masterSlaveServerGroupId_;
-}
-
-std::vector<CreateMasterSlaveServerGroupResult::MasterSlaveBackendServer> CreateMasterSlaveServerGroupResult::getMasterSlaveBackendServers()const
-{
-	return masterSlaveBackendServers_;
-}
-
+std::string CreateMasterSlaveServerGroupResult::getMasterSlaveServerGroupId()const
+{
+	return masterSlaveServerGroupId_;
+}
+
+std::vector<CreateMasterSlaveServerGroupResult::MasterSlaveBackendServer> CreateMasterSlaveServerGroupResult::getMasterSlaveBackendServers()const
+{
+	return masterSlaveBackendServers_;
+}
+

slb/src/model/CreateMasterSlaveVServerGroupResult.cc

@@ -40,32 +40,40 @@ void CreateMasterSlaveVServerGroupResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allMasterSlaveBackendServers = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
-	for (auto value : allMasterSlaveBackendServers)
-	{
-		MasterSlaveBackendServer masterSlaveBackendServersObject;
-		if(!value["ServerId"].isNull())
-			masterSlaveBackendServersObject.serverId = value["ServerId"].asString();
-		if(!value["Port"].isNull())
-			masterSlaveBackendServersObject.port = std::stoi(value["Port"].asString());
-		if(!value["Weight"].isNull())
-			masterSlaveBackendServersObject.weight = std::stoi(value["Weight"].asString());
-		if(!value["IsBackup"].isNull())
-			masterSlaveBackendServersObject.isBackup = std::stoi(value["IsBackup"].asString());
-		masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
-	}
-	if(!value["MasterSlaveVServerGroupId"].isNull())
-		masterSlaveVServerGroupId_ = value["MasterSlaveVServerGroupId"].asString();
+	auto allMasterSlaveBackendServers = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
+	for (auto value : allMasterSlaveBackendServers)
+	{
+		MasterSlaveBackendServer masterSlaveBackendServersObject;
+		if(!value["ServerId"].isNull())
+			masterSlaveBackendServersObject.serverId = value["ServerId"].asString();
+		if(!value["Port"].isNull())
+			masterSlaveBackendServersObject.port = std::stoi(value["Port"].asString());
+		if(!value["Weight"].isNull())
+			masterSlaveBackendServersObject.weight = std::stoi(value["Weight"].asString());
+		if(!value["IsBackup"].isNull())
+			masterSlaveBackendServersObject.isBackup = std::stoi(value["IsBackup"].asString());
+		if(!value["Type"].isNull())
+			masterSlaveBackendServersObject.type = value["Type"].asString();
+		if(!value["ServerIp"].isNull())
+			masterSlaveBackendServersObject.serverIp = value["ServerIp"].asString();
+		if(!value["EniHost"].isNull())
+			masterSlaveBackendServersObject.eniHost = value["EniHost"].asString();
+		if(!value["VpcId"].isNull())
+			masterSlaveBackendServersObject.vpcId = value["VpcId"].asString();
+		masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
+	}
+	if(!value["MasterSlaveVServerGroupId"].isNull())
+		masterSlaveVServerGroupId_ = value["MasterSlaveVServerGroupId"].asString();
 
 }
 
-std::string CreateMasterSlaveVServerGroupResult::getMasterSlaveVServerGroupId()const
-{
-	return masterSlaveVServerGroupId_;
-}
-
-std::vector<CreateMasterSlaveVServerGroupResult::MasterSlaveBackendServer> CreateMasterSlaveVServerGroupResult::getMasterSlaveBackendServers()const
-{
-	return masterSlaveBackendServers_;
-}
-
+std::string CreateMasterSlaveVServerGroupResult::getMasterSlaveVServerGroupId()const
+{
+	return masterSlaveVServerGroupId_;
+}
+
+std::vector<CreateMasterSlaveVServerGroupResult::MasterSlaveBackendServer> CreateMasterSlaveVServerGroupResult::getMasterSlaveBackendServers()const
+{
+	return masterSlaveBackendServers_;
+}
+

slb/src/model/CreateRulesResult.cc

@@ -40,21 +40,21 @@ void CreateRulesResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allRules = value["Rules"]["Rule"];
-	for (auto value : allRules)
-	{
-		Rule rulesObject;
-		if(!value["RuleId"].isNull())
-			rulesObject.ruleId = value["RuleId"].asString();
-		if(!value["RuleName"].isNull())
-			rulesObject.ruleName = value["RuleName"].asString();
-		rules_.push_back(rulesObject);
-	}
+	auto allRules = value["Rules"]["Rule"];
+	for (auto value : allRules)
+	{
+		Rule rulesObject;
+		if(!value["RuleId"].isNull())
+			rulesObject.ruleId = value["RuleId"].asString();
+		if(!value["RuleName"].isNull())
+			rulesObject.ruleName = value["RuleName"].asString();
+		rules_.push_back(rulesObject);
+	}
 
 }
 
-std::vector<CreateRulesResult::Rule> CreateRulesResult::getRules()const
-{
-	return rules_;
-}
-
+std::vector<CreateRulesResult::Rule> CreateRulesResult::getRules()const
+{
+	return rules_;
+}
+

slb/src/model/CreateVServerGroupResult.cc

@@ -40,30 +40,38 @@ void CreateVServerGroupResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allBackendServers = value["BackendServers"]["BackendServer"];
-	for (auto value : allBackendServers)
-	{
-		BackendServer backendServersObject;
-		if(!value["ServerId"].isNull())
-			backendServersObject.serverId = value["ServerId"].asString();
-		if(!value["Port"].isNull())
-			backendServersObject.port = std::stoi(value["Port"].asString());
-		if(!value["Weight"].isNull())
-			backendServersObject.weight = std::stoi(value["Weight"].asString());
-		backendServers_.push_back(backendServersObject);
-	}
-	if(!value["VServerGroupId"].isNull())
-		vServerGroupId_ = value["VServerGroupId"].asString();
+	auto allBackendServers = value["BackendServers"]["BackendServer"];
+	for (auto value : allBackendServers)
+	{
+		BackendServer backendServersObject;
+		if(!value["ServerId"].isNull())
+			backendServersObject.serverId = value["ServerId"].asString();
+		if(!value["Port"].isNull())
+			backendServersObject.port = std::stoi(value["Port"].asString());
+		if(!value["Weight"].isNull())
+			backendServersObject.weight = std::stoi(value["Weight"].asString());
+		if(!value["Type"].isNull())
+			backendServersObject.type = value["Type"].asString();
+		if(!value["ServerIp"].isNull())
+			backendServersObject.serverIp = value["ServerIp"].asString();
+		if(!value["EniHost"].isNull())
+			backendServersObject.eniHost = value["EniHost"].asString();
+		if(!value["VpcId"].isNull())
+			backendServersObject.vpcId = value["VpcId"].asString();
+		backendServers_.push_back(backendServersObject);
+	}
+	if(!value["VServerGroupId"].isNull())
+		vServerGroupId_ = value["VServerGroupId"].asString();
 
 }
 
-std::string CreateVServerGroupResult::getVServerGroupId()const
-{
-	return vServerGroupId_;
-}
-
-std::vector<CreateVServerGroupResult::BackendServer> CreateVServerGroupResult::getBackendServers()const
-{
-	return backendServers_;
-}
-
+std::string CreateVServerGroupResult::getVServerGroupId()const
+{
+	return vServerGroupId_;
+}
+
+std::vector<CreateVServerGroupResult::BackendServer> CreateVServerGroupResult::getBackendServers()const
+{
+	return backendServers_;
+}
+

slb/src/model/DeleteAccessControlListRequest.cc

@@ -0,0 +1,126 @@
+/*
+ * 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/slb/model/DeleteAccessControlListRequest.h>
+
+using AlibabaCloud::Slb::Model::DeleteAccessControlListRequest;
+
+DeleteAccessControlListRequest::DeleteAccessControlListRequest() :
+	RpcServiceRequest("slb", "2014-05-15", "DeleteAccessControlList")
+{}
+
+DeleteAccessControlListRequest::~DeleteAccessControlListRequest()
+{}
+
+std::string DeleteAccessControlListRequest::getAccess_key_id()const
+{
+	return access_key_id_;
+}
+
+void DeleteAccessControlListRequest::setAccess_key_id(const std::string& access_key_id)
+{
+	access_key_id_ = access_key_id;
+	setParameter("Access_key_id", access_key_id);
+}
+
+std::string DeleteAccessControlListRequest::getAclId()const
+{
+	return aclId_;
+}
+
+void DeleteAccessControlListRequest::setAclId(const std::string& aclId)
+{
+	aclId_ = aclId;
+	setParameter("AclId", aclId);
+}
+
+long DeleteAccessControlListRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DeleteAccessControlListRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DeleteAccessControlListRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DeleteAccessControlListRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DeleteAccessControlListRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteAccessControlListRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DeleteAccessControlListRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DeleteAccessControlListRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DeleteAccessControlListRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DeleteAccessControlListRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DeleteAccessControlListRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DeleteAccessControlListRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DeleteAccessControlListRequest::getTags()const
+{
+	return tags_;
+}
+
+void DeleteAccessControlListRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+

slb/src/model/DeleteAccessControlListResult.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/slb/model/DeleteAccessControlListResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DeleteAccessControlListResult::DeleteAccessControlListResult() :
+	ServiceResult()
+{}
+
+DeleteAccessControlListResult::DeleteAccessControlListResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteAccessControlListResult::~DeleteAccessControlListResult()
+{}
+
+void DeleteAccessControlListResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+
+}
+

slb/src/model/DeleteDomainExtensionRequest.cc

@@ -0,0 +1,115 @@
+/*
+ * 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/slb/model/DeleteDomainExtensionRequest.h>
+
+using AlibabaCloud::Slb::Model::DeleteDomainExtensionRequest;
+
+DeleteDomainExtensionRequest::DeleteDomainExtensionRequest() :
+	RpcServiceRequest("slb", "2014-05-15", "DeleteDomainExtension")
+{}
+
+DeleteDomainExtensionRequest::~DeleteDomainExtensionRequest()
+{}
+
+std::string DeleteDomainExtensionRequest::getAccess_key_id()const
+{
+	return access_key_id_;
+}
+
+void DeleteDomainExtensionRequest::setAccess_key_id(const std::string& access_key_id)
+{
+	access_key_id_ = access_key_id;
+	setParameter("Access_key_id", access_key_id);
+}
+
+long DeleteDomainExtensionRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DeleteDomainExtensionRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DeleteDomainExtensionRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DeleteDomainExtensionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DeleteDomainExtensionRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteDomainExtensionRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DeleteDomainExtensionRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DeleteDomainExtensionRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DeleteDomainExtensionRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DeleteDomainExtensionRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DeleteDomainExtensionRequest::getTags()const
+{
+	return tags_;
+}
+
+void DeleteDomainExtensionRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+
+std::string DeleteDomainExtensionRequest::getDomainExtensionId()const
+{
+	return domainExtensionId_;
+}
+
+void DeleteDomainExtensionRequest::setDomainExtensionId(const std::string& domainExtensionId)
+{
+	domainExtensionId_ = domainExtensionId;
+	setParameter("DomainExtensionId", domainExtensionId);
+}
+

slb/src/model/DeleteDomainExtensionResult.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/slb/model/DeleteDomainExtensionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DeleteDomainExtensionResult::DeleteDomainExtensionResult() :
+	ServiceResult()
+{}
+
+DeleteDomainExtensionResult::DeleteDomainExtensionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteDomainExtensionResult::~DeleteDomainExtensionResult()
+{}
+
+void DeleteDomainExtensionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+
+}
+

slb/src/model/DescribeAccessControlListAttributeRequest.cc

@@ -0,0 +1,137 @@
+/*
+ * 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/slb/model/DescribeAccessControlListAttributeRequest.h>
+
+using AlibabaCloud::Slb::Model::DescribeAccessControlListAttributeRequest;
+
+DescribeAccessControlListAttributeRequest::DescribeAccessControlListAttributeRequest() :
+	RpcServiceRequest("slb", "2014-05-15", "DescribeAccessControlListAttribute")
+{}
+
+DescribeAccessControlListAttributeRequest::~DescribeAccessControlListAttributeRequest()
+{}
+
+std::string DescribeAccessControlListAttributeRequest::getAccess_key_id()const
+{
+	return access_key_id_;
+}
+
+void DescribeAccessControlListAttributeRequest::setAccess_key_id(const std::string& access_key_id)
+{
+	access_key_id_ = access_key_id;
+	setParameter("Access_key_id", access_key_id);
+}
+
+std::string DescribeAccessControlListAttributeRequest::getAclId()const
+{
+	return aclId_;
+}
+
+void DescribeAccessControlListAttributeRequest::setAclId(const std::string& aclId)
+{
+	aclId_ = aclId;
+	setParameter("AclId", aclId);
+}
+
+long DescribeAccessControlListAttributeRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeAccessControlListAttributeRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeAccessControlListAttributeRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeAccessControlListAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeAccessControlListAttributeRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeAccessControlListAttributeRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DescribeAccessControlListAttributeRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeAccessControlListAttributeRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string DescribeAccessControlListAttributeRequest::getAclEntryComment()const
+{
+	return aclEntryComment_;
+}
+
+void DescribeAccessControlListAttributeRequest::setAclEntryComment(const std::string& aclEntryComment)
+{
+	aclEntryComment_ = aclEntryComment;
+	setParameter("AclEntryComment", aclEntryComment);
+}
+
+long DescribeAccessControlListAttributeRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeAccessControlListAttributeRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeAccessControlListAttributeRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeAccessControlListAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeAccessControlListAttributeRequest::getTags()const
+{
+	return tags_;
+}
+
+void DescribeAccessControlListAttributeRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+

slb/src/model/DescribeAccessControlListAttributeResult.cc

@@ -0,0 +1,100 @@
+/*
+ * 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/slb/model/DescribeAccessControlListAttributeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DescribeAccessControlListAttributeResult::DescribeAccessControlListAttributeResult() :
+	ServiceResult()
+{}
+
+DescribeAccessControlListAttributeResult::DescribeAccessControlListAttributeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeAccessControlListAttributeResult::~DescribeAccessControlListAttributeResult()
+{}
+
+void DescribeAccessControlListAttributeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allAclEntrys = value["AclEntrys"]["AclEntry"];
+	for (auto value : allAclEntrys)
+	{
+		AclEntry aclEntrysObject;
+		if(!value["AclEntryIP"].isNull())
+			aclEntrysObject.aclEntryIP = value["AclEntryIP"].asString();
+		if(!value["AclEntryComment"].isNull())
+			aclEntrysObject.aclEntryComment = value["AclEntryComment"].asString();
+		aclEntrys_.push_back(aclEntrysObject);
+	}
+	auto allRelatedListeners = value["RelatedListeners"]["RelatedListener"];
+	for (auto value : allRelatedListeners)
+	{
+		RelatedListener relatedListenersObject;
+		if(!value["LoadBalancerId"].isNull())
+			relatedListenersObject.loadBalancerId = value["LoadBalancerId"].asString();
+		if(!value["ListenerPort"].isNull())
+			relatedListenersObject.listenerPort = std::stoi(value["ListenerPort"].asString());
+		if(!value["AclType"].isNull())
+			relatedListenersObject.aclType = value["AclType"].asString();
+		if(!value["Protocol"].isNull())
+			relatedListenersObject.protocol = value["Protocol"].asString();
+		relatedListeners_.push_back(relatedListenersObject);
+	}
+	if(!value["AclId"].isNull())
+		aclId_ = value["AclId"].asString();
+	if(!value["AclName"].isNull())
+		aclName_ = value["AclName"].asString();
+	if(!value["AddressIPVersion"].isNull())
+		addressIPVersion_ = value["AddressIPVersion"].asString();
+
+}
+
+std::vector<DescribeAccessControlListAttributeResult::AclEntry> DescribeAccessControlListAttributeResult::getAclEntrys()const
+{
+	return aclEntrys_;
+}
+
+std::string DescribeAccessControlListAttributeResult::getAclId()const
+{
+	return aclId_;
+}
+
+std::string DescribeAccessControlListAttributeResult::getAddressIPVersion()const
+{
+	return addressIPVersion_;
+}
+
+std::vector<DescribeAccessControlListAttributeResult::RelatedListener> DescribeAccessControlListAttributeResult::getRelatedListeners()const
+{
+	return relatedListeners_;
+}
+
+std::string DescribeAccessControlListAttributeResult::getAclName()const
+{
+	return aclName_;
+}
+

slb/src/model/DescribeAccessControlListsRequest.cc

@@ -0,0 +1,159 @@
+/*
+ * 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/slb/model/DescribeAccessControlListsRequest.h>
+
+using AlibabaCloud::Slb::Model::DescribeAccessControlListsRequest;
+
+DescribeAccessControlListsRequest::DescribeAccessControlListsRequest() :
+	RpcServiceRequest("slb", "2014-05-15", "DescribeAccessControlLists")
+{}
+
+DescribeAccessControlListsRequest::~DescribeAccessControlListsRequest()
+{}
+
+std::string DescribeAccessControlListsRequest::getAccess_key_id()const
+{
+	return access_key_id_;
+}
+
+void DescribeAccessControlListsRequest::setAccess_key_id(const std::string& access_key_id)
+{
+	access_key_id_ = access_key_id;
+	setParameter("Access_key_id", access_key_id);
+}
+
+long DescribeAccessControlListsRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeAccessControlListsRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeAccessControlListsRequest::getAclName()const
+{
+	return aclName_;
+}
+
+void DescribeAccessControlListsRequest::setAclName(const std::string& aclName)
+{
+	aclName_ = aclName;
+	setParameter("AclName", aclName);
+}
+
+std::string DescribeAccessControlListsRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeAccessControlListsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeAccessControlListsRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeAccessControlListsRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DescribeAccessControlListsRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeAccessControlListsRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeAccessControlListsRequest::getAddressIPVersion()const
+{
+	return addressIPVersion_;
+}
+
+void DescribeAccessControlListsRequest::setAddressIPVersion(const std::string& addressIPVersion)
+{
+	addressIPVersion_ = addressIPVersion;
+	setParameter("AddressIPVersion", addressIPVersion);
+}
+
+int DescribeAccessControlListsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeAccessControlListsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DescribeAccessControlListsRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeAccessControlListsRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeAccessControlListsRequest::getTags()const
+{
+	return tags_;
+}
+
+void DescribeAccessControlListsRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+
+std::string DescribeAccessControlListsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeAccessControlListsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+int DescribeAccessControlListsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeAccessControlListsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+

slb/src/model/DescribeAccessControlListsResult.cc

@@ -0,0 +1,62 @@
+/*
+ * 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/slb/model/DescribeAccessControlListsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DescribeAccessControlListsResult::DescribeAccessControlListsResult() :
+	ServiceResult()
+{}
+
+DescribeAccessControlListsResult::DescribeAccessControlListsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeAccessControlListsResult::~DescribeAccessControlListsResult()
+{}
+
+void DescribeAccessControlListsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allAcls = value["Acls"]["Acl"];
+	for (auto value : allAcls)
+	{
+		Acl aclsObject;
+		if(!value["AclId"].isNull())
+			aclsObject.aclId = value["AclId"].asString();
+		if(!value["AclName"].isNull())
+			aclsObject.aclName = value["AclName"].asString();
+		if(!value["AddressIPVersion"].isNull())
+			aclsObject.addressIPVersion = value["AddressIPVersion"].asString();
+		acls_.push_back(aclsObject);
+	}
+
+}
+
+std::vector<DescribeAccessControlListsResult::Acl> DescribeAccessControlListsResult::getAcls()const
+{
+	return acls_;
+}
+

slb/src/model/DescribeCACertificatesResult.cc

@@ -40,31 +40,37 @@ void DescribeCACertificatesResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allCACertificates = value["CACertificates"]["CACertificate"];
-	for (auto value : allCACertificates)
-	{
-		CACertificate cACertificatesObject;
-		if(!value["RegionId"].isNull())
-			cACertificatesObject.regionId = value["RegionId"].asString();
-		if(!value["CACertificateId"].isNull())
-			cACertificatesObject.cACertificateId = value["CACertificateId"].asString();
-		if(!value["CACertificateName"].isNull())
-			cACertificatesObject.cACertificateName = value["CACertificateName"].asString();
-		if(!value["Fingerprint"].isNull())
-			cACertificatesObject.fingerprint = value["Fingerprint"].asString();
-		if(!value["ResourceGroupId"].isNull())
-			cACertificatesObject.resourceGroupId = value["ResourceGroupId"].asString();
-		if(!value["CreateTime"].isNull())
-			cACertificatesObject.createTime = value["CreateTime"].asString();
-		if(!value["CreateTimeStamp"].isNull())
-			cACertificatesObject.createTimeStamp = std::stol(value["CreateTimeStamp"].asString());
-		cACertificates_.push_back(cACertificatesObject);
-	}
+	auto allCACertificates = value["CACertificates"]["CACertificate"];
+	for (auto value : allCACertificates)
+	{
+		CACertificate cACertificatesObject;
+		if(!value["RegionId"].isNull())
+			cACertificatesObject.regionId = value["RegionId"].asString();
+		if(!value["CACertificateId"].isNull())
+			cACertificatesObject.cACertificateId = value["CACertificateId"].asString();
+		if(!value["CACertificateName"].isNull())
+			cACertificatesObject.cACertificateName = value["CACertificateName"].asString();
+		if(!value["Fingerprint"].isNull())
+			cACertificatesObject.fingerprint = value["Fingerprint"].asString();
+		if(!value["ResourceGroupId"].isNull())
+			cACertificatesObject.resourceGroupId = value["ResourceGroupId"].asString();
+		if(!value["CreateTime"].isNull())
+			cACertificatesObject.createTime = value["CreateTime"].asString();
+		if(!value["CreateTimeStamp"].isNull())
+			cACertificatesObject.createTimeStamp = std::stol(value["CreateTimeStamp"].asString());
+		if(!value["ExpireTime"].isNull())
+			cACertificatesObject.expireTime = value["ExpireTime"].asString();
+		if(!value["ExpireTimeStamp"].isNull())
+			cACertificatesObject.expireTimeStamp = std::stol(value["ExpireTimeStamp"].asString());
+		if(!value["CommonName"].isNull())
+			cACertificatesObject.commonName = value["CommonName"].asString();
+		cACertificates_.push_back(cACertificatesObject);
+	}
 
 }
 
-std::vector<DescribeCACertificatesResult::CACertificate> DescribeCACertificatesResult::getCACertificates()const
-{
-	return cACertificates_;
-}
-
+std::vector<DescribeCACertificatesResult::CACertificate> DescribeCACertificatesResult::getCACertificates()const
+{
+	return cACertificates_;
+}
+

slb/src/model/DescribeDomainExtensionsRequest.cc

@@ -0,0 +1,137 @@
+/*
+ * 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/slb/model/DescribeDomainExtensionsRequest.h>
+
+using AlibabaCloud::Slb::Model::DescribeDomainExtensionsRequest;
+
+DescribeDomainExtensionsRequest::DescribeDomainExtensionsRequest() :
+	RpcServiceRequest("slb", "2014-05-15", "DescribeDomainExtensions")
+{}
+
+DescribeDomainExtensionsRequest::~DescribeDomainExtensionsRequest()
+{}
+
+std::string DescribeDomainExtensionsRequest::getAccess_key_id()const
+{
+	return access_key_id_;
+}
+
+void DescribeDomainExtensionsRequest::setAccess_key_id(const std::string& access_key_id)
+{
+	access_key_id_ = access_key_id;
+	setParameter("Access_key_id", access_key_id);
+}
+
+long DescribeDomainExtensionsRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeDomainExtensionsRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+int DescribeDomainExtensionsRequest::getListenerPort()const
+{
+	return listenerPort_;
+}
+
+void DescribeDomainExtensionsRequest::setListenerPort(int listenerPort)
+{
+	listenerPort_ = listenerPort;
+	setParameter("ListenerPort", std::to_string(listenerPort));
+}
+
+std::string DescribeDomainExtensionsRequest::getLoadBalancerId()const
+{
+	return loadBalancerId_;
+}
+
+void DescribeDomainExtensionsRequest::setLoadBalancerId(const std::string& loadBalancerId)
+{
+	loadBalancerId_ = loadBalancerId;
+	setParameter("LoadBalancerId", loadBalancerId);
+}
+
+std::string DescribeDomainExtensionsRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeDomainExtensionsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeDomainExtensionsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeDomainExtensionsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DescribeDomainExtensionsRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeDomainExtensionsRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DescribeDomainExtensionsRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDomainExtensionsRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeDomainExtensionsRequest::getTags()const
+{
+	return tags_;
+}
+
+void DescribeDomainExtensionsRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+
+std::string DescribeDomainExtensionsRequest::getDomainExtensionId()const
+{
+	return domainExtensionId_;
+}
+
+void DescribeDomainExtensionsRequest::setDomainExtensionId(const std::string& domainExtensionId)
+{
+	domainExtensionId_ = domainExtensionId;
+	setParameter("DomainExtensionId", domainExtensionId);
+}
+

slb/src/model/DescribeDomainExtensionsResult.cc

@@ -0,0 +1,62 @@
+/*
+ * 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/slb/model/DescribeDomainExtensionsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DescribeDomainExtensionsResult::DescribeDomainExtensionsResult() :
+	ServiceResult()
+{}
+
+DescribeDomainExtensionsResult::DescribeDomainExtensionsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDomainExtensionsResult::~DescribeDomainExtensionsResult()
+{}
+
+void DescribeDomainExtensionsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allDomainExtensions = value["DomainExtensions"]["DomainExtension"];
+	for (auto value : allDomainExtensions)
+	{
+		DomainExtension domainExtensionsObject;
+		if(!value["DomainExtensionId"].isNull())
+			domainExtensionsObject.domainExtensionId = value["DomainExtensionId"].asString();
+		if(!value["Domain"].isNull())
+			domainExtensionsObject.domain = value["Domain"].asString();
+		if(!value["ServerCertificateId"].isNull())
+			domainExtensionsObject.serverCertificateId = value["ServerCertificateId"].asString();
+		domainExtensions_.push_back(domainExtensionsObject);
+	}
+
+}
+
+std::vector<DescribeDomainExtensionsResult::DomainExtension> DescribeDomainExtensionsResult::getDomainExtensions()const
+{
+	return domainExtensions_;
+}
+

slb/src/model/DescribeHealthStatusResult.cc

@@ -40,25 +40,31 @@ void DescribeHealthStatusResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allBackendServers = value["BackendServers"]["BackendServer"];
-	for (auto value : allBackendServers)
-	{
-		BackendServer backendServersObject;
-		if(!value["ListenerPort"].isNull())
-			backendServersObject.listenerPort = std::stoi(value["ListenerPort"].asString());
-		if(!value["ServerId"].isNull())
-			backendServersObject.serverId = value["ServerId"].asString();
-		if(!value["Port"].isNull())
-			backendServersObject.port = std::stoi(value["Port"].asString());
-		if(!value["ServerHealthStatus"].isNull())
-			backendServersObject.serverHealthStatus = value["ServerHealthStatus"].asString();
-		backendServers_.push_back(backendServersObject);
-	}
+	auto allBackendServers = value["BackendServers"]["BackendServer"];
+	for (auto value : allBackendServers)
+	{
+		BackendServer backendServersObject;
+		if(!value["ListenerPort"].isNull())
+			backendServersObject.listenerPort = std::stoi(value["ListenerPort"].asString());
+		if(!value["ServerId"].isNull())
+			backendServersObject.serverId = value["ServerId"].asString();
+		if(!value["Port"].isNull())
+			backendServersObject.port = std::stoi(value["Port"].asString());
+		if(!value["ServerHealthStatus"].isNull())
+			backendServersObject.serverHealthStatus = value["ServerHealthStatus"].asString();
+		if(!value["ServerIp"].isNull())
+			backendServersObject.serverIp = value["ServerIp"].asString();
+		if(!value["EniHost"].isNull())
+			backendServersObject.eniHost = value["EniHost"].asString();
+		if(!value["Type"].isNull())
+			backendServersObject.type = value["Type"].asString();
+		backendServers_.push_back(backendServersObject);
+	}
 
 }
 
-std::vector<DescribeHealthStatusResult::BackendServer> DescribeHealthStatusResult::getBackendServers()const
-{
-	return backendServers_;
-}
-
+std::vector<DescribeHealthStatusResult::BackendServer> DescribeHealthStatusResult::getBackendServers()const
+{
+	return backendServers_;
+}
+

slb/src/model/DescribeListenerAccessControlAttributeResult.cc

@@ -40,20 +40,20 @@ void DescribeListenerAccessControlAttributeResult::parse(const std::string &payl
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["AccessControlStatus"].isNull())
-		accessControlStatus_ = value["AccessControlStatus"].asString();
-	if(!value["SourceItems"].isNull())
-		sourceItems_ = value["SourceItems"].asString();
+	if(!value["AccessControlStatus"].isNull())
+		accessControlStatus_ = value["AccessControlStatus"].asString();
+	if(!value["SourceItems"].isNull())
+		sourceItems_ = value["SourceItems"].asString();
 
 }
 
-std::string DescribeListenerAccessControlAttributeResult::getAccessControlStatus()const
-{
-	return accessControlStatus_;
-}
-
-std::string DescribeListenerAccessControlAttributeResult::getSourceItems()const
-{
-	return sourceItems_;
-}
-
+std::string DescribeListenerAccessControlAttributeResult::getAccessControlStatus()const
+{
+	return accessControlStatus_;
+}
+
+std::string DescribeListenerAccessControlAttributeResult::getSourceItems()const
+{
+	return sourceItems_;
+}
+

slb/src/model/DescribeLoadBalancerAttributeResult.cc

@@ -40,213 +40,260 @@ void DescribeLoadBalancerAttributeResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allListenerPortsAndProtocal = value["ListenerPortsAndProtocal"]["ListenerPortAndProtocal"];
-	for (auto value : allListenerPortsAndProtocal)
-	{
-		ListenerPortAndProtocal listenerPortsAndProtocalObject;
-		if(!value["ListenerPort"].isNull())
-			listenerPortsAndProtocalObject.listenerPort = std::stoi(value["ListenerPort"].asString());
-		if(!value["ListenerProtocal"].isNull())
-			listenerPortsAndProtocalObject.listenerProtocal = value["ListenerProtocal"].asString();
-		listenerPortsAndProtocal_.push_back(listenerPortsAndProtocalObject);
-	}
-	auto allListenerPortsAndProtocol = value["ListenerPortsAndProtocol"]["ListenerPortAndProtocol"];
-	for (auto value : allListenerPortsAndProtocol)
-	{
-		ListenerPortAndProtocol listenerPortsAndProtocolObject;
-		if(!value["ListenerPort"].isNull())
-			listenerPortsAndProtocolObject.listenerPort = std::stoi(value["ListenerPort"].asString());
-		if(!value["ListenerProtocol"].isNull())
-			listenerPortsAndProtocolObject.listenerProtocol = value["ListenerProtocol"].asString();
-		listenerPortsAndProtocol_.push_back(listenerPortsAndProtocolObject);
-	}
-	auto allBackendServers = value["BackendServers"]["BackendServer"];
-	for (auto value : allBackendServers)
-	{
-		BackendServer backendServersObject;
-		if(!value["ServerId"].isNull())
-			backendServersObject.serverId = value["ServerId"].asString();
-		if(!value["Weight"].isNull())
-			backendServersObject.weight = std::stoi(value["Weight"].asString());
-		backendServers_.push_back(backendServersObject);
-	}
-	auto allListenerPorts = value["ListenerPorts"]["ListenerPort"];
-	for (const auto &item : allListenerPorts)
-		listenerPorts_.push_back(item.asString());
-	if(!value["LoadBalancerId"].isNull())
-		loadBalancerId_ = value["LoadBalancerId"].asString();
-	if(!value["ResourceGroupId"].isNull())
-		resourceGroupId_ = value["ResourceGroupId"].asString();
-	if(!value["LoadBalancerName"].isNull())
-		loadBalancerName_ = value["LoadBalancerName"].asString();
-	if(!value["LoadBalancerStatus"].isNull())
-		loadBalancerStatus_ = value["LoadBalancerStatus"].asString();
-	if(!value["RegionId"].isNull())
-		regionId_ = value["RegionId"].asString();
-	if(!value["RegionIdAlias"].isNull())
-		regionIdAlias_ = value["RegionIdAlias"].asString();
-	if(!value["Address"].isNull())
-		address_ = value["Address"].asString();
-	if(!value["AddressType"].isNull())
-		addressType_ = value["AddressType"].asString();
-	if(!value["VpcId"].isNull())
-		vpcId_ = value["VpcId"].asString();
-	if(!value["VSwitchId"].isNull())
-		vSwitchId_ = value["VSwitchId"].asString();
-	if(!value["NetworkType"].isNull())
-		networkType_ = value["NetworkType"].asString();
-	if(!value["InternetChargeType"].isNull())
-		internetChargeType_ = value["InternetChargeType"].asString();
-	if(!value["AutoReleaseTime"].isNull())
-		autoReleaseTime_ = std::stol(value["AutoReleaseTime"].asString());
-	if(!value["Bandwidth"].isNull())
-		bandwidth_ = std::stoi(value["Bandwidth"].asString());
-	if(!value["LoadBalancerSpec"].isNull())
-		loadBalancerSpec_ = value["LoadBalancerSpec"].asString();
-	if(!value["CreateTime"].isNull())
-		createTime_ = value["CreateTime"].asString();
-	if(!value["CreateTimeStamp"].isNull())
-		createTimeStamp_ = std::stol(value["CreateTimeStamp"].asString());
-	if(!value["EndTime"].isNull())
-		endTime_ = value["EndTime"].asString();
-	if(!value["EndTimeStamp"].isNull())
-		endTimeStamp_ = std::stol(value["EndTimeStamp"].asString());
-	if(!value["PayType"].isNull())
-		payType_ = value["PayType"].asString();
-	if(!value["MasterZoneId"].isNull())
-		masterZoneId_ = value["MasterZoneId"].asString();
-	if(!value["SlaveZoneId"].isNull())
-		slaveZoneId_ = value["SlaveZoneId"].asString();
+	auto allListenerPortsAndProtocal = value["ListenerPortsAndProtocal"]["ListenerPortAndProtocal"];
+	for (auto value : allListenerPortsAndProtocal)
+	{
+		ListenerPortAndProtocal listenerPortsAndProtocalObject;
+		if(!value["ListenerPort"].isNull())
+			listenerPortsAndProtocalObject.listenerPort = std::stoi(value["ListenerPort"].asString());
+		if(!value["ListenerProtocal"].isNull())
+			listenerPortsAndProtocalObject.listenerProtocal = value["ListenerProtocal"].asString();
+		listenerPortsAndProtocal_.push_back(listenerPortsAndProtocalObject);
+	}
+	auto allListenerPortsAndProtocol = value["ListenerPortsAndProtocol"]["ListenerPortAndProtocol"];
+	for (auto value : allListenerPortsAndProtocol)
+	{
+		ListenerPortAndProtocol listenerPortsAndProtocolObject;
+		if(!value["ListenerPort"].isNull())
+			listenerPortsAndProtocolObject.listenerPort = std::stoi(value["ListenerPort"].asString());
+		if(!value["ListenerProtocol"].isNull())
+			listenerPortsAndProtocolObject.listenerProtocol = value["ListenerProtocol"].asString();
+		if(!value["ListenerForward"].isNull())
+			listenerPortsAndProtocolObject.listenerForward = value["ListenerForward"].asString();
+		if(!value["ForwardPort"].isNull())
+			listenerPortsAndProtocolObject.forwardPort = std::stoi(value["ForwardPort"].asString());
+		listenerPortsAndProtocol_.push_back(listenerPortsAndProtocolObject);
+	}
+	auto allBackendServers = value["BackendServers"]["BackendServer"];
+	for (auto value : allBackendServers)
+	{
+		BackendServer backendServersObject;
+		if(!value["ServerId"].isNull())
+			backendServersObject.serverId = value["ServerId"].asString();
+		if(!value["Weight"].isNull())
+			backendServersObject.weight = std::stoi(value["Weight"].asString());
+		if(!value["Type"].isNull())
+			backendServersObject.type = value["Type"].asString();
+		if(!value["ServerIp"].isNull())
+			backendServersObject.serverIp = value["ServerIp"].asString();
+		if(!value["EniHost"].isNull())
+			backendServersObject.eniHost = value["EniHost"].asString();
+		if(!value["VpcId"].isNull())
+			backendServersObject.vpcId = value["VpcId"].asString();
+		backendServers_.push_back(backendServersObject);
+	}
+	auto allListenerPorts = value["ListenerPorts"]["ListenerPort"];
+	for (const auto &item : allListenerPorts)
+		listenerPorts_.push_back(item.asString());
+	if(!value["LoadBalancerId"].isNull())
+		loadBalancerId_ = value["LoadBalancerId"].asString();
+	if(!value["ResourceGroupId"].isNull())
+		resourceGroupId_ = value["ResourceGroupId"].asString();
+	if(!value["LoadBalancerName"].isNull())
+		loadBalancerName_ = value["LoadBalancerName"].asString();
+	if(!value["LoadBalancerStatus"].isNull())
+		loadBalancerStatus_ = value["LoadBalancerStatus"].asString();
+	if(!value["RegionId"].isNull())
+		regionId_ = value["RegionId"].asString();
+	if(!value["RegionIdAlias"].isNull())
+		regionIdAlias_ = value["RegionIdAlias"].asString();
+	if(!value["Address"].isNull())
+		address_ = value["Address"].asString();
+	if(!value["AddressType"].isNull())
+		addressType_ = value["AddressType"].asString();
+	if(!value["VpcId"].isNull())
+		vpcId_ = value["VpcId"].asString();
+	if(!value["VSwitchId"].isNull())
+		vSwitchId_ = value["VSwitchId"].asString();
+	if(!value["NetworkType"].isNull())
+		networkType_ = value["NetworkType"].asString();
+	if(!value["InternetChargeType"].isNull())
+		internetChargeType_ = value["InternetChargeType"].asString();
+	if(!value["AutoReleaseTime"].isNull())
+		autoReleaseTime_ = std::stol(value["AutoReleaseTime"].asString());
+	if(!value["Bandwidth"].isNull())
+		bandwidth_ = std::stoi(value["Bandwidth"].asString());
+	if(!value["LoadBalancerSpec"].isNull())
+		loadBalancerSpec_ = value["LoadBalancerSpec"].asString();
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["CreateTimeStamp"].isNull())
+		createTimeStamp_ = std::stol(value["CreateTimeStamp"].asString());
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+	if(!value["EndTimeStamp"].isNull())
+		endTimeStamp_ = std::stol(value["EndTimeStamp"].asString());
+	if(!value["PayType"].isNull())
+		payType_ = value["PayType"].asString();
+	if(!value["MasterZoneId"].isNull())
+		masterZoneId_ = value["MasterZoneId"].asString();
+	if(!value["SlaveZoneId"].isNull())
+		slaveZoneId_ = value["SlaveZoneId"].asString();
+	if(!value["AddressIPVersion"].isNull())
+		addressIPVersion_ = value["AddressIPVersion"].asString();
+	if(!value["CloudType"].isNull())
+		cloudType_ = value["CloudType"].asString();
+	if(!value["RenewalDuration"].isNull())
+		renewalDuration_ = std::stoi(value["RenewalDuration"].asString());
+	if(!value["RenewalStatus"].isNull())
+		renewalStatus_ = value["RenewalStatus"].asString();
+	if(!value["RenewalCycUnit"].isNull())
+		renewalCycUnit_ = value["RenewalCycUnit"].asString();
 
 }
 
-std::vector<DescribeLoadBalancerAttributeResult::ListenerPortAndProtocal> DescribeLoadBalancerAttributeResult::getListenerPortsAndProtocal()const
-{
-	return listenerPortsAndProtocal_;
-}
-
-std::string DescribeLoadBalancerAttributeResult::getResourceGroupId()const
-{
-	return resourceGroupId_;
-}
-
-std::string DescribeLoadBalancerAttributeResult::getAddress()const
-{
-	return address_;
-}
-
-std::string DescribeLoadBalancerAttributeResult::getEndTime()const
-{
-	return endTime_;
-}
-
-std::vector<DescribeLoadBalancerAttributeResult::ListenerPortAndProtocol> DescribeLoadBalancerAttributeResult::getListenerPortsAndProtocol()const
-{
-	return listenerPortsAndProtocol_;
-}
-
-std::string DescribeLoadBalancerAttributeResult::getLoadBalancerId()const
-{
-	return loadBalancerId_;
-}
-
-std::vector<DescribeLoadBalancerAttributeResult::BackendServer> DescribeLoadBalancerAttributeResult::getBackendServers()const
-{
-	return backendServers_;
-}
-
-std::string DescribeLoadBalancerAttributeResult::getLoadBalancerSpec()const
-{
-	return loadBalancerSpec_;
-}
-
-std::string DescribeLoadBalancerAttributeResult::getNetworkType()const
-{
-	return networkType_;
-}
-
-int DescribeLoadBalancerAttributeResult::getBandwidth()const
-{
-	return bandwidth_;
-}
-
-std::vector<std::string> DescribeLoadBalancerAttributeResult::getListenerPorts()const
-{
-	return listenerPorts_;
-}
-
-std::string DescribeLoadBalancerAttributeResult::getMasterZoneId()const
-{
-	return masterZoneId_;
-}
-
-std::string DescribeLoadBalancerAttributeResult::getVSwitchId()const
-{
-	return vSwitchId_;
-}
-
-std::string DescribeLoadBalancerAttributeResult::getCreateTime()const
-{
-	return createTime_;
-}
-
-std::string DescribeLoadBalancerAttributeResult::getPayType()const
-{
-	return payType_;
-}
-
-std::string DescribeLoadBalancerAttributeResult::getSlaveZoneId()const
-{
-	return slaveZoneId_;
-}
-
-std::string DescribeLoadBalancerAttributeResult::getInternetChargeType()const
-{
-	return internetChargeType_;
-}
-
-std::string DescribeLoadBalancerAttributeResult::getRegionIdAlias()const
-{
-	return regionIdAlias_;
-}
-
-std::string DescribeLoadBalancerAttributeResult::getLoadBalancerName()const
-{
-	return loadBalancerName_;
-}
-
-std::string DescribeLoadBalancerAttributeResult::getVpcId()const
-{
-	return vpcId_;
-}
-
-long DescribeLoadBalancerAttributeResult::getEndTimeStamp()const
-{
-	return endTimeStamp_;
-}
-
-std::string DescribeLoadBalancerAttributeResult::getRegionId()const
-{
-	return regionId_;
-}
-
-std::string DescribeLoadBalancerAttributeResult::getAddressType()const
-{
-	return addressType_;
-}
-
-std::string DescribeLoadBalancerAttributeResult::getLoadBalancerStatus()const
-{
-	return loadBalancerStatus_;
-}
-
-long DescribeLoadBalancerAttributeResult::getCreateTimeStamp()const
-{
-	return createTimeStamp_;
-}
-
-long DescribeLoadBalancerAttributeResult::getAutoReleaseTime()const
-{
-	return autoReleaseTime_;
-}
-
+int DescribeLoadBalancerAttributeResult::getRenewalDuration()const
+{
+	return renewalDuration_;
+}
+
+std::vector<DescribeLoadBalancerAttributeResult::ListenerPortAndProtocal> DescribeLoadBalancerAttributeResult::getListenerPortsAndProtocal()const
+{
+	return listenerPortsAndProtocal_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getAddress()const
+{
+	return address_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getAddressIPVersion()const
+{
+	return addressIPVersion_;
+}
+
+std::vector<DescribeLoadBalancerAttributeResult::ListenerPortAndProtocol> DescribeLoadBalancerAttributeResult::getListenerPortsAndProtocol()const
+{
+	return listenerPortsAndProtocol_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getLoadBalancerId()const
+{
+	return loadBalancerId_;
+}
+
+std::vector<DescribeLoadBalancerAttributeResult::BackendServer> DescribeLoadBalancerAttributeResult::getBackendServers()const
+{
+	return backendServers_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getLoadBalancerSpec()const
+{
+	return loadBalancerSpec_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getNetworkType()const
+{
+	return networkType_;
+}
+
+int DescribeLoadBalancerAttributeResult::getBandwidth()const
+{
+	return bandwidth_;
+}
+
+std::vector<std::string> DescribeLoadBalancerAttributeResult::getListenerPorts()const
+{
+	return listenerPorts_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getMasterZoneId()const
+{
+	return masterZoneId_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getCloudType()const
+{
+	return cloudType_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getVSwitchId()const
+{
+	return vSwitchId_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getRenewalStatus()const
+{
+	return renewalStatus_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getRenewalCycUnit()const
+{
+	return renewalCycUnit_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getPayType()const
+{
+	return payType_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getSlaveZoneId()const
+{
+	return slaveZoneId_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getInternetChargeType()const
+{
+	return internetChargeType_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getRegionIdAlias()const
+{
+	return regionIdAlias_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getLoadBalancerName()const
+{
+	return loadBalancerName_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getVpcId()const
+{
+	return vpcId_;
+}
+
+long DescribeLoadBalancerAttributeResult::getEndTimeStamp()const
+{
+	return endTimeStamp_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getRegionId()const
+{
+	return regionId_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getAddressType()const
+{
+	return addressType_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getLoadBalancerStatus()const
+{
+	return loadBalancerStatus_;
+}
+
+long DescribeLoadBalancerAttributeResult::getCreateTimeStamp()const
+{
+	return createTimeStamp_;
+}
+
+long DescribeLoadBalancerAttributeResult::getAutoReleaseTime()const
+{
+	return autoReleaseTime_;
+}
+

slb/src/model/DescribeLoadBalancerAutoReleaseTimeResult.cc

@@ -40,13 +40,13 @@ void DescribeLoadBalancerAutoReleaseTimeResult::parse(const std::string &payload
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["AutoReleaseTime"].isNull())
-		autoReleaseTime_ = std::stol(value["AutoReleaseTime"].asString());
+	if(!value["AutoReleaseTime"].isNull())
+		autoReleaseTime_ = std::stol(value["AutoReleaseTime"].asString());
 
 }
 
-long DescribeLoadBalancerAutoReleaseTimeResult::getAutoReleaseTime()const
-{
-	return autoReleaseTime_;
-}
-
+long DescribeLoadBalancerAutoReleaseTimeResult::getAutoReleaseTime()const
+{
+	return autoReleaseTime_;
+}
+

slb/src/model/DescribeLoadBalancerHTTPListenerAttributeResult.cc

@@ -40,188 +40,272 @@ void DescribeLoadBalancerHTTPListenerAttributeResult::parse(const std::string &p
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["ListenerPort"].isNull())
-		listenerPort_ = std::stoi(value["ListenerPort"].asString());
-	if(!value["BackendServerPort"].isNull())
-		backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
-	if(!value["Bandwidth"].isNull())
-		bandwidth_ = std::stoi(value["Bandwidth"].asString());
-	if(!value["Status"].isNull())
-		status_ = value["Status"].asString();
-	if(!value["SecurityStatus"].isNull())
-		securityStatus_ = value["SecurityStatus"].asString();
-	if(!value["XForwardedFor"].isNull())
-		xForwardedFor_ = value["XForwardedFor"].asString();
-	if(!value["Scheduler"].isNull())
-		scheduler_ = value["Scheduler"].asString();
-	if(!value["StickySession"].isNull())
-		stickySession_ = value["StickySession"].asString();
-	if(!value["StickySessionType"].isNull())
-		stickySessionType_ = value["StickySessionType"].asString();
-	if(!value["CookieTimeout"].isNull())
-		cookieTimeout_ = std::stoi(value["CookieTimeout"].asString());
-	if(!value["Cookie"].isNull())
-		cookie_ = value["Cookie"].asString();
-	if(!value["HealthCheck"].isNull())
-		healthCheck_ = value["HealthCheck"].asString();
-	if(!value["HealthCheckDomain"].isNull())
-		healthCheckDomain_ = value["HealthCheckDomain"].asString();
-	if(!value["HealthCheckURI"].isNull())
-		healthCheckURI_ = value["HealthCheckURI"].asString();
-	if(!value["HealthyThreshold"].isNull())
-		healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
-	if(!value["UnhealthyThreshold"].isNull())
-		unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
-	if(!value["HealthCheckTimeout"].isNull())
-		healthCheckTimeout_ = std::stoi(value["HealthCheckTimeout"].asString());
-	if(!value["HealthCheckInterval"].isNull())
-		healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
-	if(!value["HealthCheckConnectPort"].isNull())
-		healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
-	if(!value["HealthCheckHttpCode"].isNull())
-		healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
-	if(!value["MaxConnection"].isNull())
-		maxConnection_ = std::stoi(value["MaxConnection"].asString());
-	if(!value["VServerGroupId"].isNull())
-		vServerGroupId_ = value["VServerGroupId"].asString();
-	if(!value["Gzip"].isNull())
-		gzip_ = value["Gzip"].asString();
-	if(!value["XForwardedFor_SLBIP"].isNull())
-		xForwardedFor_SLBIP_ = value["XForwardedFor_SLBIP"].asString();
-	if(!value["XForwardedFor_SLBID"].isNull())
-		xForwardedFor_SLBID_ = value["XForwardedFor_SLBID"].asString();
-	if(!value["XForwardedFor_proto"].isNull())
-		xForwardedFor_proto_ = value["XForwardedFor_proto"].asString();
+	auto allRules = value["Rules"]["Rule"];
+	for (auto value : allRules)
+	{
+		Rule rulesObject;
+		if(!value["RuleId"].isNull())
+			rulesObject.ruleId = value["RuleId"].asString();
+		if(!value["RuleName"].isNull())
+			rulesObject.ruleName = value["RuleName"].asString();
+		if(!value["Domain"].isNull())
+			rulesObject.domain = value["Domain"].asString();
+		if(!value["Url"].isNull())
+			rulesObject.url = value["Url"].asString();
+		if(!value["VServerGroupId"].isNull())
+			rulesObject.vServerGroupId = value["VServerGroupId"].asString();
+		rules_.push_back(rulesObject);
+	}
+	if(!value["ListenerPort"].isNull())
+		listenerPort_ = std::stoi(value["ListenerPort"].asString());
+	if(!value["BackendServerPort"].isNull())
+		backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
+	if(!value["Bandwidth"].isNull())
+		bandwidth_ = std::stoi(value["Bandwidth"].asString());
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["SecurityStatus"].isNull())
+		securityStatus_ = value["SecurityStatus"].asString();
+	if(!value["XForwardedFor"].isNull())
+		xForwardedFor_ = value["XForwardedFor"].asString();
+	if(!value["Scheduler"].isNull())
+		scheduler_ = value["Scheduler"].asString();
+	if(!value["StickySession"].isNull())
+		stickySession_ = value["StickySession"].asString();
+	if(!value["StickySessionType"].isNull())
+		stickySessionType_ = value["StickySessionType"].asString();
+	if(!value["CookieTimeout"].isNull())
+		cookieTimeout_ = std::stoi(value["CookieTimeout"].asString());
+	if(!value["Cookie"].isNull())
+		cookie_ = value["Cookie"].asString();
+	if(!value["HealthCheck"].isNull())
+		healthCheck_ = value["HealthCheck"].asString();
+	if(!value["HealthCheckDomain"].isNull())
+		healthCheckDomain_ = value["HealthCheckDomain"].asString();
+	if(!value["HealthCheckURI"].isNull())
+		healthCheckURI_ = value["HealthCheckURI"].asString();
+	if(!value["HealthyThreshold"].isNull())
+		healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
+	if(!value["UnhealthyThreshold"].isNull())
+		unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
+	if(!value["HealthCheckTimeout"].isNull())
+		healthCheckTimeout_ = std::stoi(value["HealthCheckTimeout"].asString());
+	if(!value["HealthCheckInterval"].isNull())
+		healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
+	if(!value["HealthCheckConnectPort"].isNull())
+		healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
+	if(!value["HealthCheckHttpCode"].isNull())
+		healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
+	if(!value["MaxConnection"].isNull())
+		maxConnection_ = std::stoi(value["MaxConnection"].asString());
+	if(!value["VServerGroupId"].isNull())
+		vServerGroupId_ = value["VServerGroupId"].asString();
+	if(!value["Gzip"].isNull())
+		gzip_ = value["Gzip"].asString();
+	if(!value["XForwardedFor_SLBIP"].isNull())
+		xForwardedFor_SLBIP_ = value["XForwardedFor_SLBIP"].asString();
+	if(!value["XForwardedFor_SLBID"].isNull())
+		xForwardedFor_SLBID_ = value["XForwardedFor_SLBID"].asString();
+	if(!value["XForwardedFor_proto"].isNull())
+		xForwardedFor_proto_ = value["XForwardedFor_proto"].asString();
+	if(!value["AclId"].isNull())
+		aclId_ = value["AclId"].asString();
+	if(!value["AclType"].isNull())
+		aclType_ = value["AclType"].asString();
+	if(!value["AclStatus"].isNull())
+		aclStatus_ = value["AclStatus"].asString();
+	if(!value["VpcIds"].isNull())
+		vpcIds_ = value["VpcIds"].asString();
+	if(!value["ListenerForward"].isNull())
+		listenerForward_ = value["ListenerForward"].asString();
+	if(!value["ForwardPort"].isNull())
+		forwardPort_ = std::stoi(value["ForwardPort"].asString());
+	if(!value["RequestTimeout"].isNull())
+		requestTimeout_ = std::stoi(value["RequestTimeout"].asString());
+	if(!value["IdleTimeout"].isNull())
+		idleTimeout_ = std::stoi(value["IdleTimeout"].asString());
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
 
 }
 
-int DescribeLoadBalancerHTTPListenerAttributeResult::getCookieTimeout()const
-{
-	return cookieTimeout_;
-}
-
-int DescribeLoadBalancerHTTPListenerAttributeResult::getMaxConnection()const
-{
-	return maxConnection_;
-}
-
-std::string DescribeLoadBalancerHTTPListenerAttributeResult::getVServerGroupId()const
-{
-	return vServerGroupId_;
-}
-
-int DescribeLoadBalancerHTTPListenerAttributeResult::getUnhealthyThreshold()const
-{
-	return unhealthyThreshold_;
-}
-
-std::string DescribeLoadBalancerHTTPListenerAttributeResult::getScheduler()const
-{
-	return scheduler_;
-}
-
-std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckURI()const
-{
-	return healthCheckURI_;
-}
-
-std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheck()const
-{
-	return healthCheck_;
-}
-
-int DescribeLoadBalancerHTTPListenerAttributeResult::getBackendServerPort()const
-{
-	return backendServerPort_;
-}
-
-std::string DescribeLoadBalancerHTTPListenerAttributeResult::getXForwardedFor_SLBID()const
-{
-	return xForwardedFor_SLBID_;
-}
-
-int DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckConnectPort()const
-{
-	return healthCheckConnectPort_;
-}
-
-int DescribeLoadBalancerHTTPListenerAttributeResult::getBandwidth()const
-{
-	return bandwidth_;
-}
-
-std::string DescribeLoadBalancerHTTPListenerAttributeResult::getSecurityStatus()const
-{
-	return securityStatus_;
-}
-
-std::string DescribeLoadBalancerHTTPListenerAttributeResult::getGzip()const
-{
-	return gzip_;
-}
-
-std::string DescribeLoadBalancerHTTPListenerAttributeResult::getStickySessionType()const
-{
-	return stickySessionType_;
-}
-
-std::string DescribeLoadBalancerHTTPListenerAttributeResult::getXForwardedFor_SLBIP()const
-{
-	return xForwardedFor_SLBIP_;
-}
-
-std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckHttpCode()const
-{
-	return healthCheckHttpCode_;
-}
-
-std::string DescribeLoadBalancerHTTPListenerAttributeResult::getStatus()const
-{
-	return status_;
-}
-
-std::string DescribeLoadBalancerHTTPListenerAttributeResult::getCookie()const
-{
-	return cookie_;
-}
-
-int DescribeLoadBalancerHTTPListenerAttributeResult::getListenerPort()const
-{
-	return listenerPort_;
-}
-
-int DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckInterval()const
-{
-	return healthCheckInterval_;
-}
-
-int DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckTimeout()const
-{
-	return healthCheckTimeout_;
-}
-
-std::string DescribeLoadBalancerHTTPListenerAttributeResult::getStickySession()const
-{
-	return stickySession_;
-}
-
-int DescribeLoadBalancerHTTPListenerAttributeResult::getHealthyThreshold()const
-{
-	return healthyThreshold_;
-}
-
-std::string DescribeLoadBalancerHTTPListenerAttributeResult::getXForwardedFor()const
-{
-	return xForwardedFor_;
-}
-
-std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckDomain()const
-{
-	return healthCheckDomain_;
-}
-
-std::string DescribeLoadBalancerHTTPListenerAttributeResult::getXForwardedFor_proto()const
-{
-	return xForwardedFor_proto_;
-}
-
+int DescribeLoadBalancerHTTPListenerAttributeResult::getCookieTimeout()const
+{
+	return cookieTimeout_;
+}
+
+int DescribeLoadBalancerHTTPListenerAttributeResult::getMaxConnection()const
+{
+	return maxConnection_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getVServerGroupId()const
+{
+	return vServerGroupId_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getDescription()const
+{
+	return description_;
+}
+
+int DescribeLoadBalancerHTTPListenerAttributeResult::getUnhealthyThreshold()const
+{
+	return unhealthyThreshold_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getScheduler()const
+{
+	return scheduler_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckURI()const
+{
+	return healthCheckURI_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheck()const
+{
+	return healthCheck_;
+}
+
+int DescribeLoadBalancerHTTPListenerAttributeResult::getIdleTimeout()const
+{
+	return idleTimeout_;
+}
+
+int DescribeLoadBalancerHTTPListenerAttributeResult::getBackendServerPort()const
+{
+	return backendServerPort_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getXForwardedFor_SLBID()const
+{
+	return xForwardedFor_SLBID_;
+}
+
+int DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckConnectPort()const
+{
+	return healthCheckConnectPort_;
+}
+
+int DescribeLoadBalancerHTTPListenerAttributeResult::getBandwidth()const
+{
+	return bandwidth_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getSecurityStatus()const
+{
+	return securityStatus_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getGzip()const
+{
+	return gzip_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getStickySessionType()const
+{
+	return stickySessionType_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getXForwardedFor_SLBIP()const
+{
+	return xForwardedFor_SLBIP_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckHttpCode()const
+{
+	return healthCheckHttpCode_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getStatus()const
+{
+	return status_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getCookie()const
+{
+	return cookie_;
+}
+
+int DescribeLoadBalancerHTTPListenerAttributeResult::getListenerPort()const
+{
+	return listenerPort_;
+}
+
+int DescribeLoadBalancerHTTPListenerAttributeResult::getRequestTimeout()const
+{
+	return requestTimeout_;
+}
+
+int DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckInterval()const
+{
+	return healthCheckInterval_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getAclId()const
+{
+	return aclId_;
+}
+
+int DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckTimeout()const
+{
+	return healthCheckTimeout_;
+}
+
+std::vector<DescribeLoadBalancerHTTPListenerAttributeResult::Rule> DescribeLoadBalancerHTTPListenerAttributeResult::getRules()const
+{
+	return rules_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getListenerForward()const
+{
+	return listenerForward_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getStickySession()const
+{
+	return stickySession_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getAclStatus()const
+{
+	return aclStatus_;
+}
+
+int DescribeLoadBalancerHTTPListenerAttributeResult::getForwardPort()const
+{
+	return forwardPort_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getVpcIds()const
+{
+	return vpcIds_;
+}
+
+int DescribeLoadBalancerHTTPListenerAttributeResult::getHealthyThreshold()const
+{
+	return healthyThreshold_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getXForwardedFor()const
+{
+	return xForwardedFor_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckDomain()const
+{
+	return healthCheckDomain_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getXForwardedFor_proto()const
+{
+	return xForwardedFor_proto_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getAclType()const
+{
+	return aclType_;
+}
+

slb/src/model/DescribeLoadBalancerHTTPSListenerAttributeResult.cc

@@ -40,202 +40,303 @@ void DescribeLoadBalancerHTTPSListenerAttributeResult::parse(const std::string &
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["ListenerPort"].isNull())
-		listenerPort_ = std::stoi(value["ListenerPort"].asString());
-	if(!value["BackendServerPort"].isNull())
-		backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
-	if(!value["Bandwidth"].isNull())
-		bandwidth_ = std::stoi(value["Bandwidth"].asString());
-	if(!value["Status"].isNull())
-		status_ = value["Status"].asString();
-	if(!value["SecurityStatus"].isNull())
-		securityStatus_ = value["SecurityStatus"].asString();
-	if(!value["XForwardedFor"].isNull())
-		xForwardedFor_ = value["XForwardedFor"].asString();
-	if(!value["Scheduler"].isNull())
-		scheduler_ = value["Scheduler"].asString();
-	if(!value["StickySession"].isNull())
-		stickySession_ = value["StickySession"].asString();
-	if(!value["StickySessionType"].isNull())
-		stickySessionType_ = value["StickySessionType"].asString();
-	if(!value["CookieTimeout"].isNull())
-		cookieTimeout_ = std::stoi(value["CookieTimeout"].asString());
-	if(!value["Cookie"].isNull())
-		cookie_ = value["Cookie"].asString();
-	if(!value["HealthCheck"].isNull())
-		healthCheck_ = value["HealthCheck"].asString();
-	if(!value["HealthCheckDomain"].isNull())
-		healthCheckDomain_ = value["HealthCheckDomain"].asString();
-	if(!value["HealthCheckURI"].isNull())
-		healthCheckURI_ = value["HealthCheckURI"].asString();
-	if(!value["HealthyThreshold"].isNull())
-		healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
-	if(!value["UnhealthyThreshold"].isNull())
-		unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
-	if(!value["HealthCheckTimeout"].isNull())
-		healthCheckTimeout_ = std::stoi(value["HealthCheckTimeout"].asString());
-	if(!value["HealthCheckInterval"].isNull())
-		healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
-	if(!value["HealthCheckConnectPort"].isNull())
-		healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
-	if(!value["HealthCheckHttpCode"].isNull())
-		healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
-	if(!value["ServerCertificateId"].isNull())
-		serverCertificateId_ = value["ServerCertificateId"].asString();
-	if(!value["CACertificateId"].isNull())
-		cACertificateId_ = value["CACertificateId"].asString();
-	if(!value["MaxConnection"].isNull())
-		maxConnection_ = std::stoi(value["MaxConnection"].asString());
-	if(!value["VServerGroupId"].isNull())
-		vServerGroupId_ = value["VServerGroupId"].asString();
-	if(!value["Gzip"].isNull())
-		gzip_ = value["Gzip"].asString();
-	if(!value["XForwardedFor_SLBIP"].isNull())
-		xForwardedFor_SLBIP_ = value["XForwardedFor_SLBIP"].asString();
-	if(!value["XForwardedFor_SLBID"].isNull())
-		xForwardedFor_SLBID_ = value["XForwardedFor_SLBID"].asString();
-	if(!value["XForwardedFor_proto"].isNull())
-		xForwardedFor_proto_ = value["XForwardedFor_proto"].asString();
+	auto allRules = value["Rules"]["Rule"];
+	for (auto value : allRules)
+	{
+		Rule rulesObject;
+		if(!value["RuleId"].isNull())
+			rulesObject.ruleId = value["RuleId"].asString();
+		if(!value["RuleName"].isNull())
+			rulesObject.ruleName = value["RuleName"].asString();
+		if(!value["Domain"].isNull())
+			rulesObject.domain = value["Domain"].asString();
+		if(!value["Url"].isNull())
+			rulesObject.url = value["Url"].asString();
+		if(!value["VServerGroupId"].isNull())
+			rulesObject.vServerGroupId = value["VServerGroupId"].asString();
+		rules_.push_back(rulesObject);
+	}
+	auto allDomainExtensions = value["DomainExtensions"]["DomainExtension"];
+	for (auto value : allDomainExtensions)
+	{
+		DomainExtension domainExtensionsObject;
+		if(!value["DomainExtensionId"].isNull())
+			domainExtensionsObject.domainExtensionId = value["DomainExtensionId"].asString();
+		if(!value["Domain"].isNull())
+			domainExtensionsObject.domain = value["Domain"].asString();
+		if(!value["ServerCertificateId"].isNull())
+			domainExtensionsObject.serverCertificateId = value["ServerCertificateId"].asString();
+		domainExtensions_.push_back(domainExtensionsObject);
+	}
+	if(!value["ListenerPort"].isNull())
+		listenerPort_ = std::stoi(value["ListenerPort"].asString());
+	if(!value["BackendServerPort"].isNull())
+		backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
+	if(!value["Bandwidth"].isNull())
+		bandwidth_ = std::stoi(value["Bandwidth"].asString());
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["SecurityStatus"].isNull())
+		securityStatus_ = value["SecurityStatus"].asString();
+	if(!value["XForwardedFor"].isNull())
+		xForwardedFor_ = value["XForwardedFor"].asString();
+	if(!value["Scheduler"].isNull())
+		scheduler_ = value["Scheduler"].asString();
+	if(!value["StickySession"].isNull())
+		stickySession_ = value["StickySession"].asString();
+	if(!value["StickySessionType"].isNull())
+		stickySessionType_ = value["StickySessionType"].asString();
+	if(!value["CookieTimeout"].isNull())
+		cookieTimeout_ = std::stoi(value["CookieTimeout"].asString());
+	if(!value["Cookie"].isNull())
+		cookie_ = value["Cookie"].asString();
+	if(!value["HealthCheck"].isNull())
+		healthCheck_ = value["HealthCheck"].asString();
+	if(!value["HealthCheckDomain"].isNull())
+		healthCheckDomain_ = value["HealthCheckDomain"].asString();
+	if(!value["HealthCheckURI"].isNull())
+		healthCheckURI_ = value["HealthCheckURI"].asString();
+	if(!value["HealthyThreshold"].isNull())
+		healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
+	if(!value["UnhealthyThreshold"].isNull())
+		unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
+	if(!value["HealthCheckTimeout"].isNull())
+		healthCheckTimeout_ = std::stoi(value["HealthCheckTimeout"].asString());
+	if(!value["HealthCheckInterval"].isNull())
+		healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
+	if(!value["HealthCheckConnectPort"].isNull())
+		healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
+	if(!value["HealthCheckHttpCode"].isNull())
+		healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
+	if(!value["ServerCertificateId"].isNull())
+		serverCertificateId_ = value["ServerCertificateId"].asString();
+	if(!value["CACertificateId"].isNull())
+		cACertificateId_ = value["CACertificateId"].asString();
+	if(!value["MaxConnection"].isNull())
+		maxConnection_ = std::stoi(value["MaxConnection"].asString());
+	if(!value["VServerGroupId"].isNull())
+		vServerGroupId_ = value["VServerGroupId"].asString();
+	if(!value["Gzip"].isNull())
+		gzip_ = value["Gzip"].asString();
+	if(!value["XForwardedFor_SLBIP"].isNull())
+		xForwardedFor_SLBIP_ = value["XForwardedFor_SLBIP"].asString();
+	if(!value["XForwardedFor_SLBID"].isNull())
+		xForwardedFor_SLBID_ = value["XForwardedFor_SLBID"].asString();
+	if(!value["XForwardedFor_proto"].isNull())
+		xForwardedFor_proto_ = value["XForwardedFor_proto"].asString();
+	if(!value["AclId"].isNull())
+		aclId_ = value["AclId"].asString();
+	if(!value["AclType"].isNull())
+		aclType_ = value["AclType"].asString();
+	if(!value["AclStatus"].isNull())
+		aclStatus_ = value["AclStatus"].asString();
+	if(!value["VpcIds"].isNull())
+		vpcIds_ = value["VpcIds"].asString();
+	if(!value["RequestTimeout"].isNull())
+		requestTimeout_ = std::stoi(value["RequestTimeout"].asString());
+	if(!value["IdleTimeout"].isNull())
+		idleTimeout_ = std::stoi(value["IdleTimeout"].asString());
+	if(!value["EnableHttp2"].isNull())
+		enableHttp2_ = value["EnableHttp2"].asString();
+	if(!value["TLSCipherPolicy"].isNull())
+		tLSCipherPolicy_ = value["TLSCipherPolicy"].asString();
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
 
 }
 
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getCookieTimeout()const
-{
-	return cookieTimeout_;
-}
-
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getMaxConnection()const
-{
-	return maxConnection_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getVServerGroupId()const
-{
-	return vServerGroupId_;
-}
-
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getUnhealthyThreshold()const
-{
-	return unhealthyThreshold_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getScheduler()const
-{
-	return scheduler_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckURI()const
-{
-	return healthCheckURI_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheck()const
-{
-	return healthCheck_;
-}
-
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getBackendServerPort()const
-{
-	return backendServerPort_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_SLBID()const
-{
-	return xForwardedFor_SLBID_;
-}
-
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckConnectPort()const
-{
-	return healthCheckConnectPort_;
-}
-
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getBandwidth()const
-{
-	return bandwidth_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getSecurityStatus()const
-{
-	return securityStatus_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getGzip()const
-{
-	return gzip_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getServerCertificateId()const
-{
-	return serverCertificateId_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStickySessionType()const
-{
-	return stickySessionType_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_SLBIP()const
-{
-	return xForwardedFor_SLBIP_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckHttpCode()const
-{
-	return healthCheckHttpCode_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStatus()const
-{
-	return status_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getCookie()const
-{
-	return cookie_;
-}
-
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getListenerPort()const
-{
-	return listenerPort_;
-}
-
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckInterval()const
-{
-	return healthCheckInterval_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getCACertificateId()const
-{
-	return cACertificateId_;
-}
-
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckTimeout()const
-{
-	return healthCheckTimeout_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStickySession()const
-{
-	return stickySession_;
-}
-
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthyThreshold()const
-{
-	return healthyThreshold_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor()const
-{
-	return xForwardedFor_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckDomain()const
-{
-	return healthCheckDomain_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_proto()const
-{
-	return xForwardedFor_proto_;
-}
-
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getCookieTimeout()const
+{
+	return cookieTimeout_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getMaxConnection()const
+{
+	return maxConnection_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getVServerGroupId()const
+{
+	return vServerGroupId_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getDescription()const
+{
+	return description_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getUnhealthyThreshold()const
+{
+	return unhealthyThreshold_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getScheduler()const
+{
+	return scheduler_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckURI()const
+{
+	return healthCheckURI_;
+}
+
+std::vector<DescribeLoadBalancerHTTPSListenerAttributeResult::DomainExtension> DescribeLoadBalancerHTTPSListenerAttributeResult::getDomainExtensions()const
+{
+	return domainExtensions_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheck()const
+{
+	return healthCheck_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getIdleTimeout()const
+{
+	return idleTimeout_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getBackendServerPort()const
+{
+	return backendServerPort_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_SLBID()const
+{
+	return xForwardedFor_SLBID_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckConnectPort()const
+{
+	return healthCheckConnectPort_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getBandwidth()const
+{
+	return bandwidth_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getSecurityStatus()const
+{
+	return securityStatus_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getGzip()const
+{
+	return gzip_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getServerCertificateId()const
+{
+	return serverCertificateId_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStickySessionType()const
+{
+	return stickySessionType_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_SLBIP()const
+{
+	return xForwardedFor_SLBIP_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckHttpCode()const
+{
+	return healthCheckHttpCode_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStatus()const
+{
+	return status_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getCookie()const
+{
+	return cookie_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getListenerPort()const
+{
+	return listenerPort_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getRequestTimeout()const
+{
+	return requestTimeout_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckInterval()const
+{
+	return healthCheckInterval_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getTLSCipherPolicy()const
+{
+	return tLSCipherPolicy_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getCACertificateId()const
+{
+	return cACertificateId_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getAclId()const
+{
+	return aclId_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckTimeout()const
+{
+	return healthCheckTimeout_;
+}
+
+std::vector<DescribeLoadBalancerHTTPSListenerAttributeResult::Rule> DescribeLoadBalancerHTTPSListenerAttributeResult::getRules()const
+{
+	return rules_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStickySession()const
+{
+	return stickySession_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getAclStatus()const
+{
+	return aclStatus_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getVpcIds()const
+{
+	return vpcIds_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthyThreshold()const
+{
+	return healthyThreshold_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor()const
+{
+	return xForwardedFor_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckDomain()const
+{
+	return healthCheckDomain_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_proto()const
+{
+	return xForwardedFor_proto_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getAclType()const
+{
+	return aclType_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getEnableHttp2()const
+{
+	return enableHttp2_;
+}
+

slb/src/model/DescribeLoadBalancerTCPListenerAttributeResult.cc

@@ -40,153 +40,188 @@ void DescribeLoadBalancerTCPListenerAttributeResult::parse(const std::string &pa
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["ListenerPort"].isNull())
-		listenerPort_ = std::stoi(value["ListenerPort"].asString());
-	if(!value["BackendServerPort"].isNull())
-		backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
-	if(!value["Status"].isNull())
-		status_ = value["Status"].asString();
-	if(!value["Bandwidth"].isNull())
-		bandwidth_ = std::stoi(value["Bandwidth"].asString());
-	if(!value["Scheduler"].isNull())
-		scheduler_ = value["Scheduler"].asString();
-	if(!value["SynProxy"].isNull())
-		synProxy_ = value["SynProxy"].asString();
-	if(!value["PersistenceTimeout"].isNull())
-		persistenceTimeout_ = std::stoi(value["PersistenceTimeout"].asString());
-	if(!value["EstablishedTimeout"].isNull())
-		establishedTimeout_ = std::stoi(value["EstablishedTimeout"].asString());
-	if(!value["HealthCheck"].isNull())
-		healthCheck_ = value["HealthCheck"].asString();
-	if(!value["HealthyThreshold"].isNull())
-		healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
-	if(!value["UnhealthyThreshold"].isNull())
-		unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
-	if(!value["HealthCheckConnectTimeout"].isNull())
-		healthCheckConnectTimeout_ = std::stoi(value["HealthCheckConnectTimeout"].asString());
-	if(!value["HealthCheckConnectPort"].isNull())
-		healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
-	if(!value["HealthCheckInterval"].isNull())
-		healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
-	if(!value["HealthCheckHttpCode"].isNull())
-		healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
-	if(!value["HealthCheckDomain"].isNull())
-		healthCheckDomain_ = value["HealthCheckDomain"].asString();
-	if(!value["HealthCheckURI"].isNull())
-		healthCheckURI_ = value["HealthCheckURI"].asString();
-	if(!value["HealthCheckType"].isNull())
-		healthCheckType_ = value["HealthCheckType"].asString();
-	if(!value["MaxConnection"].isNull())
-		maxConnection_ = std::stoi(value["MaxConnection"].asString());
-	if(!value["VServerGroupId"].isNull())
-		vServerGroupId_ = value["VServerGroupId"].asString();
-	if(!value["MasterSlaveServerGroupId"].isNull())
-		masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
+	if(!value["ListenerPort"].isNull())
+		listenerPort_ = std::stoi(value["ListenerPort"].asString());
+	if(!value["BackendServerPort"].isNull())
+		backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["Bandwidth"].isNull())
+		bandwidth_ = std::stoi(value["Bandwidth"].asString());
+	if(!value["Scheduler"].isNull())
+		scheduler_ = value["Scheduler"].asString();
+	if(!value["SynProxy"].isNull())
+		synProxy_ = value["SynProxy"].asString();
+	if(!value["PersistenceTimeout"].isNull())
+		persistenceTimeout_ = std::stoi(value["PersistenceTimeout"].asString());
+	if(!value["EstablishedTimeout"].isNull())
+		establishedTimeout_ = std::stoi(value["EstablishedTimeout"].asString());
+	if(!value["HealthCheck"].isNull())
+		healthCheck_ = value["HealthCheck"].asString();
+	if(!value["HealthyThreshold"].isNull())
+		healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
+	if(!value["UnhealthyThreshold"].isNull())
+		unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
+	if(!value["HealthCheckConnectTimeout"].isNull())
+		healthCheckConnectTimeout_ = std::stoi(value["HealthCheckConnectTimeout"].asString());
+	if(!value["HealthCheckConnectPort"].isNull())
+		healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
+	if(!value["HealthCheckInterval"].isNull())
+		healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
+	if(!value["HealthCheckHttpCode"].isNull())
+		healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
+	if(!value["HealthCheckDomain"].isNull())
+		healthCheckDomain_ = value["HealthCheckDomain"].asString();
+	if(!value["HealthCheckURI"].isNull())
+		healthCheckURI_ = value["HealthCheckURI"].asString();
+	if(!value["HealthCheckType"].isNull())
+		healthCheckType_ = value["HealthCheckType"].asString();
+	if(!value["MaxConnection"].isNull())
+		maxConnection_ = std::stoi(value["MaxConnection"].asString());
+	if(!value["VServerGroupId"].isNull())
+		vServerGroupId_ = value["VServerGroupId"].asString();
+	if(!value["MasterSlaveServerGroupId"].isNull())
+		masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
+	if(!value["AclId"].isNull())
+		aclId_ = value["AclId"].asString();
+	if(!value["AclType"].isNull())
+		aclType_ = value["AclType"].asString();
+	if(!value["AclStatus"].isNull())
+		aclStatus_ = value["AclStatus"].asString();
+	if(!value["VpcIds"].isNull())
+		vpcIds_ = value["VpcIds"].asString();
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
 
 }
 
-std::string DescribeLoadBalancerTCPListenerAttributeResult::getStatus()const
-{
-	return status_;
-}
-
-int DescribeLoadBalancerTCPListenerAttributeResult::getMaxConnection()const
-{
-	return maxConnection_;
-}
-
-int DescribeLoadBalancerTCPListenerAttributeResult::getListenerPort()const
-{
-	return listenerPort_;
-}
-
-std::string DescribeLoadBalancerTCPListenerAttributeResult::getVServerGroupId()const
-{
-	return vServerGroupId_;
-}
-
-std::string DescribeLoadBalancerTCPListenerAttributeResult::getSynProxy()const
-{
-	return synProxy_;
-}
-
-int DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckInterval()const
-{
-	return healthCheckInterval_;
-}
-
-int DescribeLoadBalancerTCPListenerAttributeResult::getUnhealthyThreshold()const
-{
-	return unhealthyThreshold_;
-}
-
-std::string DescribeLoadBalancerTCPListenerAttributeResult::getScheduler()const
-{
-	return scheduler_;
-}
-
-std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckURI()const
-{
-	return healthCheckURI_;
-}
-
-std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheck()const
-{
-	return healthCheck_;
-}
-
-int DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckConnectTimeout()const
-{
-	return healthCheckConnectTimeout_;
-}
-
-int DescribeLoadBalancerTCPListenerAttributeResult::getBackendServerPort()const
-{
-	return backendServerPort_;
-}
-
-int DescribeLoadBalancerTCPListenerAttributeResult::getPersistenceTimeout()const
-{
-	return persistenceTimeout_;
-}
-
-int DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckConnectPort()const
-{
-	return healthCheckConnectPort_;
-}
-
-int DescribeLoadBalancerTCPListenerAttributeResult::getBandwidth()const
-{
-	return bandwidth_;
-}
-
-int DescribeLoadBalancerTCPListenerAttributeResult::getHealthyThreshold()const
-{
-	return healthyThreshold_;
-}
-
-std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckDomain()const
-{
-	return healthCheckDomain_;
-}
-
-std::string DescribeLoadBalancerTCPListenerAttributeResult::getMasterSlaveServerGroupId()const
-{
-	return masterSlaveServerGroupId_;
-}
-
-std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckHttpCode()const
-{
-	return healthCheckHttpCode_;
-}
-
-std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckType()const
-{
-	return healthCheckType_;
-}
-
-int DescribeLoadBalancerTCPListenerAttributeResult::getEstablishedTimeout()const
-{
-	return establishedTimeout_;
-}
-
+int DescribeLoadBalancerTCPListenerAttributeResult::getMaxConnection()const
+{
+	return maxConnection_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getVServerGroupId()const
+{
+	return vServerGroupId_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getSynProxy()const
+{
+	return synProxy_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getDescription()const
+{
+	return description_;
+}
+
+int DescribeLoadBalancerTCPListenerAttributeResult::getUnhealthyThreshold()const
+{
+	return unhealthyThreshold_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getScheduler()const
+{
+	return scheduler_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckURI()const
+{
+	return healthCheckURI_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheck()const
+{
+	return healthCheck_;
+}
+
+int DescribeLoadBalancerTCPListenerAttributeResult::getBackendServerPort()const
+{
+	return backendServerPort_;
+}
+
+int DescribeLoadBalancerTCPListenerAttributeResult::getPersistenceTimeout()const
+{
+	return persistenceTimeout_;
+}
+
+int DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckConnectPort()const
+{
+	return healthCheckConnectPort_;
+}
+
+int DescribeLoadBalancerTCPListenerAttributeResult::getBandwidth()const
+{
+	return bandwidth_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckHttpCode()const
+{
+	return healthCheckHttpCode_;
+}
+
+int DescribeLoadBalancerTCPListenerAttributeResult::getEstablishedTimeout()const
+{
+	return establishedTimeout_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getStatus()const
+{
+	return status_;
+}
+
+int DescribeLoadBalancerTCPListenerAttributeResult::getListenerPort()const
+{
+	return listenerPort_;
+}
+
+int DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckInterval()const
+{
+	return healthCheckInterval_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getAclId()const
+{
+	return aclId_;
+}
+
+int DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckConnectTimeout()const
+{
+	return healthCheckConnectTimeout_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getAclStatus()const
+{
+	return aclStatus_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getVpcIds()const
+{
+	return vpcIds_;
+}
+
+int DescribeLoadBalancerTCPListenerAttributeResult::getHealthyThreshold()const
+{
+	return healthyThreshold_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckDomain()const
+{
+	return healthCheckDomain_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getMasterSlaveServerGroupId()const
+{
+	return masterSlaveServerGroupId_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getAclType()const
+{
+	return aclType_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckType()const
+{
+	return healthCheckType_;
+}
+

slb/src/model/DescribeLoadBalancerUDPListenerAttributeResult.cc

@@ -40,125 +40,160 @@ void DescribeLoadBalancerUDPListenerAttributeResult::parse(const std::string &pa
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["ListenerPort"].isNull())
-		listenerPort_ = std::stoi(value["ListenerPort"].asString());
-	if(!value["BackendServerPort"].isNull())
-		backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
-	if(!value["Status"].isNull())
-		status_ = value["Status"].asString();
-	if(!value["Bandwidth"].isNull())
-		bandwidth_ = std::stoi(value["Bandwidth"].asString());
-	if(!value["Scheduler"].isNull())
-		scheduler_ = value["Scheduler"].asString();
-	if(!value["PersistenceTimeout"].isNull())
-		persistenceTimeout_ = std::stoi(value["PersistenceTimeout"].asString());
-	if(!value["HealthCheck"].isNull())
-		healthCheck_ = value["HealthCheck"].asString();
-	if(!value["HealthyThreshold"].isNull())
-		healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
-	if(!value["UnhealthyThreshold"].isNull())
-		unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
-	if(!value["HealthCheckConnectTimeout"].isNull())
-		healthCheckConnectTimeout_ = std::stoi(value["HealthCheckConnectTimeout"].asString());
-	if(!value["HealthCheckConnectPort"].isNull())
-		healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
-	if(!value["HealthCheckInterval"].isNull())
-		healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
-	if(!value["HealthCheckReq"].isNull())
-		healthCheckReq_ = value["HealthCheckReq"].asString();
-	if(!value["HealthCheckExp"].isNull())
-		healthCheckExp_ = value["HealthCheckExp"].asString();
-	if(!value["MaxConnection"].isNull())
-		maxConnection_ = std::stoi(value["MaxConnection"].asString());
-	if(!value["VServerGroupId"].isNull())
-		vServerGroupId_ = value["VServerGroupId"].asString();
-	if(!value["MasterSlaveServerGroupId"].isNull())
-		masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
+	if(!value["ListenerPort"].isNull())
+		listenerPort_ = std::stoi(value["ListenerPort"].asString());
+	if(!value["BackendServerPort"].isNull())
+		backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["Bandwidth"].isNull())
+		bandwidth_ = std::stoi(value["Bandwidth"].asString());
+	if(!value["Scheduler"].isNull())
+		scheduler_ = value["Scheduler"].asString();
+	if(!value["PersistenceTimeout"].isNull())
+		persistenceTimeout_ = std::stoi(value["PersistenceTimeout"].asString());
+	if(!value["HealthCheck"].isNull())
+		healthCheck_ = value["HealthCheck"].asString();
+	if(!value["HealthyThreshold"].isNull())
+		healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
+	if(!value["UnhealthyThreshold"].isNull())
+		unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
+	if(!value["HealthCheckConnectTimeout"].isNull())
+		healthCheckConnectTimeout_ = std::stoi(value["HealthCheckConnectTimeout"].asString());
+	if(!value["HealthCheckConnectPort"].isNull())
+		healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
+	if(!value["HealthCheckInterval"].isNull())
+		healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
+	if(!value["HealthCheckReq"].isNull())
+		healthCheckReq_ = value["HealthCheckReq"].asString();
+	if(!value["HealthCheckExp"].isNull())
+		healthCheckExp_ = value["HealthCheckExp"].asString();
+	if(!value["MaxConnection"].isNull())
+		maxConnection_ = std::stoi(value["MaxConnection"].asString());
+	if(!value["VServerGroupId"].isNull())
+		vServerGroupId_ = value["VServerGroupId"].asString();
+	if(!value["MasterSlaveServerGroupId"].isNull())
+		masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
+	if(!value["AclId"].isNull())
+		aclId_ = value["AclId"].asString();
+	if(!value["AclType"].isNull())
+		aclType_ = value["AclType"].asString();
+	if(!value["AclStatus"].isNull())
+		aclStatus_ = value["AclStatus"].asString();
+	if(!value["VpcIds"].isNull())
+		vpcIds_ = value["VpcIds"].asString();
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
 
 }
 
-std::string DescribeLoadBalancerUDPListenerAttributeResult::getStatus()const
-{
-	return status_;
-}
-
-int DescribeLoadBalancerUDPListenerAttributeResult::getMaxConnection()const
-{
-	return maxConnection_;
-}
-
-int DescribeLoadBalancerUDPListenerAttributeResult::getListenerPort()const
-{
-	return listenerPort_;
-}
-
-std::string DescribeLoadBalancerUDPListenerAttributeResult::getVServerGroupId()const
-{
-	return vServerGroupId_;
-}
-
-int DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckInterval()const
-{
-	return healthCheckInterval_;
-}
-
-int DescribeLoadBalancerUDPListenerAttributeResult::getUnhealthyThreshold()const
-{
-	return unhealthyThreshold_;
-}
-
-std::string DescribeLoadBalancerUDPListenerAttributeResult::getScheduler()const
-{
-	return scheduler_;
-}
-
-std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheck()const
-{
-	return healthCheck_;
-}
-
-int DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckConnectTimeout()const
-{
-	return healthCheckConnectTimeout_;
-}
-
-int DescribeLoadBalancerUDPListenerAttributeResult::getBackendServerPort()const
-{
-	return backendServerPort_;
-}
-
-int DescribeLoadBalancerUDPListenerAttributeResult::getPersistenceTimeout()const
-{
-	return persistenceTimeout_;
-}
-
-int DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckConnectPort()const
-{
-	return healthCheckConnectPort_;
-}
-
-std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckReq()const
-{
-	return healthCheckReq_;
-}
-
-int DescribeLoadBalancerUDPListenerAttributeResult::getBandwidth()const
-{
-	return bandwidth_;
-}
-
-int DescribeLoadBalancerUDPListenerAttributeResult::getHealthyThreshold()const
-{
-	return healthyThreshold_;
-}
-
-std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckExp()const
-{
-	return healthCheckExp_;
-}
-
-std::string DescribeLoadBalancerUDPListenerAttributeResult::getMasterSlaveServerGroupId()const
-{
-	return masterSlaveServerGroupId_;
-}
-
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getStatus()const
+{
+	return status_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getMaxConnection()const
+{
+	return maxConnection_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getListenerPort()const
+{
+	return listenerPort_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getVServerGroupId()const
+{
+	return vServerGroupId_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckInterval()const
+{
+	return healthCheckInterval_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getDescription()const
+{
+	return description_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getUnhealthyThreshold()const
+{
+	return unhealthyThreshold_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getScheduler()const
+{
+	return scheduler_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getAclId()const
+{
+	return aclId_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheck()const
+{
+	return healthCheck_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckConnectTimeout()const
+{
+	return healthCheckConnectTimeout_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getBackendServerPort()const
+{
+	return backendServerPort_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getPersistenceTimeout()const
+{
+	return persistenceTimeout_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckConnectPort()const
+{
+	return healthCheckConnectPort_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckReq()const
+{
+	return healthCheckReq_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getAclStatus()const
+{
+	return aclStatus_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getVpcIds()const
+{
+	return vpcIds_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getBandwidth()const
+{
+	return bandwidth_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getHealthyThreshold()const
+{
+	return healthyThreshold_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckExp()const
+{
+	return healthCheckExp_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getMasterSlaveServerGroupId()const
+{
+	return masterSlaveServerGroupId_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getAclType()const
+{
+	return aclType_;
+}
+

slb/src/model/DescribeLoadBalancersRelatedEcsResult.cc

@@ -40,97 +40,97 @@ void DescribeLoadBalancersRelatedEcsResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allLoadBalancers = value["LoadBalancers"]["LoadBalancer"];
-	for (auto value : allLoadBalancers)
-	{
-		LoadBalancer loadBalancersObject;
-		if(!value["LoadBalancerId"].isNull())
-			loadBalancersObject.loadBalancerId = value["LoadBalancerId"].asString();
-		if(!value["Count"].isNull())
-			loadBalancersObject.count = std::stoi(value["Count"].asString());
-		auto allMasterSlaveVServerGroups = value["MasterSlaveVServerGroups"]["MasterSlaveVServerGroup"];
-		for (auto value : allMasterSlaveVServerGroups)
-		{
-			LoadBalancer::MasterSlaveVServerGroup masterSlaveVServerGroupsObject;
-			if(!value["GroupId"].isNull())
-				masterSlaveVServerGroupsObject.groupId = value["GroupId"].asString();
-			if(!value["GroupName"].isNull())
-				masterSlaveVServerGroupsObject.groupName = value["GroupName"].asString();
-			auto allBackendServers1 = value["BackendServers"]["BackendServer"];
-			for (auto value : allBackendServers1)
-			{
-				LoadBalancer::MasterSlaveVServerGroup::BackendServer backendServers1Object;
-				if(!value["VmName"].isNull())
-					backendServers1Object.vmName = value["VmName"].asString();
-				if(!value["Weight"].isNull())
-					backendServers1Object.weight = std::stoi(value["Weight"].asString());
-				if(!value["Port"].isNull())
-					backendServers1Object.port = std::stoi(value["Port"].asString());
-				if(!value["NetworkType"].isNull())
-					backendServers1Object.networkType = value["NetworkType"].asString();
-				masterSlaveVServerGroupsObject.backendServers1.push_back(backendServers1Object);
-			}
-			loadBalancersObject.masterSlaveVServerGroups.push_back(masterSlaveVServerGroupsObject);
-		}
-		auto allVServerGroups = value["VServerGroups"]["VServerGroup"];
-		for (auto value : allVServerGroups)
-		{
-			LoadBalancer::VServerGroup vServerGroupsObject;
-			if(!value["GroupId"].isNull())
-				vServerGroupsObject.groupId = value["GroupId"].asString();
-			if(!value["GroupName"].isNull())
-				vServerGroupsObject.groupName = value["GroupName"].asString();
-			auto allBackendServers2 = value["BackendServers"]["BackendServer"];
-			for (auto value : allBackendServers2)
-			{
-				LoadBalancer::VServerGroup::BackendServer3 backendServers2Object;
-				if(!value["VmName"].isNull())
-					backendServers2Object.vmName = value["VmName"].asString();
-				if(!value["Weight"].isNull())
-					backendServers2Object.weight = std::stoi(value["Weight"].asString());
-				if(!value["Port"].isNull())
-					backendServers2Object.port = std::stoi(value["Port"].asString());
-				if(!value["NetworkType"].isNull())
-					backendServers2Object.networkType = value["NetworkType"].asString();
-				vServerGroupsObject.backendServers2.push_back(backendServers2Object);
-			}
-			loadBalancersObject.vServerGroups.push_back(vServerGroupsObject);
-		}
-		auto allBackendServers = value["BackendServers"]["BackendServer"];
-		for (auto value : allBackendServers)
-		{
-			LoadBalancer::BackendServer4 backendServersObject;
-			if(!value["VmName"].isNull())
-				backendServersObject.vmName = value["VmName"].asString();
-			if(!value["Weight"].isNull())
-				backendServersObject.weight = std::stoi(value["Weight"].asString());
-			if(!value["Port"].isNull())
-				backendServersObject.port = std::stoi(value["Port"].asString());
-			if(!value["NetworkType"].isNull())
-				backendServersObject.networkType = value["NetworkType"].asString();
-			loadBalancersObject.backendServers.push_back(backendServersObject);
-		}
-		loadBalancers_.push_back(loadBalancersObject);
-	}
-	if(!value["Message"].isNull())
-		message_ = value["Message"].asString();
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
+	auto allLoadBalancers = value["LoadBalancers"]["LoadBalancer"];
+	for (auto value : allLoadBalancers)
+	{
+		LoadBalancer loadBalancersObject;
+		if(!value["LoadBalancerId"].isNull())
+			loadBalancersObject.loadBalancerId = value["LoadBalancerId"].asString();
+		if(!value["Count"].isNull())
+			loadBalancersObject.count = std::stoi(value["Count"].asString());
+		auto allMasterSlaveVServerGroups = value["MasterSlaveVServerGroups"]["MasterSlaveVServerGroup"];
+		for (auto value : allMasterSlaveVServerGroups)
+		{
+			LoadBalancer::MasterSlaveVServerGroup masterSlaveVServerGroupsObject;
+			if(!value["GroupId"].isNull())
+				masterSlaveVServerGroupsObject.groupId = value["GroupId"].asString();
+			if(!value["GroupName"].isNull())
+				masterSlaveVServerGroupsObject.groupName = value["GroupName"].asString();
+			auto allBackendServers1 = value["BackendServers"]["BackendServer"];
+			for (auto value : allBackendServers1)
+			{
+				LoadBalancer::MasterSlaveVServerGroup::BackendServer backendServers1Object;
+				if(!value["VmName"].isNull())
+					backendServers1Object.vmName = value["VmName"].asString();
+				if(!value["Weight"].isNull())
+					backendServers1Object.weight = std::stoi(value["Weight"].asString());
+				if(!value["Port"].isNull())
+					backendServers1Object.port = std::stoi(value["Port"].asString());
+				if(!value["NetworkType"].isNull())
+					backendServers1Object.networkType = value["NetworkType"].asString();
+				masterSlaveVServerGroupsObject.backendServers1.push_back(backendServers1Object);
+			}
+			loadBalancersObject.masterSlaveVServerGroups.push_back(masterSlaveVServerGroupsObject);
+		}
+		auto allVServerGroups = value["VServerGroups"]["VServerGroup"];
+		for (auto value : allVServerGroups)
+		{
+			LoadBalancer::VServerGroup vServerGroupsObject;
+			if(!value["GroupId"].isNull())
+				vServerGroupsObject.groupId = value["GroupId"].asString();
+			if(!value["GroupName"].isNull())
+				vServerGroupsObject.groupName = value["GroupName"].asString();
+			auto allBackendServers2 = value["BackendServers"]["BackendServer"];
+			for (auto value : allBackendServers2)
+			{
+				LoadBalancer::VServerGroup::BackendServer3 backendServers2Object;
+				if(!value["VmName"].isNull())
+					backendServers2Object.vmName = value["VmName"].asString();
+				if(!value["Weight"].isNull())
+					backendServers2Object.weight = std::stoi(value["Weight"].asString());
+				if(!value["Port"].isNull())
+					backendServers2Object.port = std::stoi(value["Port"].asString());
+				if(!value["NetworkType"].isNull())
+					backendServers2Object.networkType = value["NetworkType"].asString();
+				vServerGroupsObject.backendServers2.push_back(backendServers2Object);
+			}
+			loadBalancersObject.vServerGroups.push_back(vServerGroupsObject);
+		}
+		auto allBackendServers = value["BackendServers"]["BackendServer"];
+		for (auto value : allBackendServers)
+		{
+			LoadBalancer::BackendServer4 backendServersObject;
+			if(!value["VmName"].isNull())
+				backendServersObject.vmName = value["VmName"].asString();
+			if(!value["Weight"].isNull())
+				backendServersObject.weight = std::stoi(value["Weight"].asString());
+			if(!value["Port"].isNull())
+				backendServersObject.port = std::stoi(value["Port"].asString());
+			if(!value["NetworkType"].isNull())
+				backendServersObject.networkType = value["NetworkType"].asString();
+			loadBalancersObject.backendServers.push_back(backendServersObject);
+		}
+		loadBalancers_.push_back(loadBalancersObject);
+	}
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 
-std::string DescribeLoadBalancersRelatedEcsResult::getMessage()const
-{
-	return message_;
-}
-
-std::vector<DescribeLoadBalancersRelatedEcsResult::LoadBalancer> DescribeLoadBalancersRelatedEcsResult::getLoadBalancers()const
-{
-	return loadBalancers_;
-}
-
-bool DescribeLoadBalancersRelatedEcsResult::getSuccess()const
-{
-	return success_;
-}
-
+std::string DescribeLoadBalancersRelatedEcsResult::getMessage()const
+{
+	return message_;
+}
+
+std::vector<DescribeLoadBalancersRelatedEcsResult::LoadBalancer> DescribeLoadBalancersRelatedEcsResult::getLoadBalancers()const
+{
+	return loadBalancers_;
+}
+
+bool DescribeLoadBalancersRelatedEcsResult::getSuccess()const
+{
+	return success_;
+}
+

slb/src/model/DescribeLoadBalancersRequest.cc

@@ -47,39 +47,6 @@ void DescribeLoadBalancersRequest::setResourceOwnerId(long resourceOwnerId)
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
-std::string DescribeLoadBalancersRequest::getAddress()const
-{
-	return address_;
-}
-
-void DescribeLoadBalancersRequest::setAddress(const std::string& address)
-{
-	address_ = address;
-	setParameter("Address", address);
-}
-
-std::string DescribeLoadBalancersRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
-}
-
-void DescribeLoadBalancersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
-}
-
-std::string DescribeLoadBalancersRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
-}
-
-void DescribeLoadBalancersRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
-}
-
 std::string DescribeLoadBalancersRequest::getNetworkType()const
 {
 	return networkType_;
@@ -91,26 +58,15 @@ void DescribeLoadBalancersRequest::setNetworkType(const std::string& networkType
 	setParameter("NetworkType", networkType);
 }
 
-long DescribeLoadBalancersRequest::getOwnerId()const
+std::string DescribeLoadBalancersRequest::getAddressIPVersion()const
 {
-	return ownerId_;
+	return addressIPVersion_;
 }
 
-void DescribeLoadBalancersRequest::setOwnerId(long ownerId)
+void DescribeLoadBalancersRequest::setAddressIPVersion(const std::string& addressIPVersion)
 {
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
-}
-
-std::string DescribeLoadBalancersRequest::getServerId()const
-{
-	return serverId_;
-}
-
-void DescribeLoadBalancersRequest::setServerId(const std::string& serverId)
-{
-	serverId_ = serverId;
-	setParameter("ServerId", serverId);
+	addressIPVersion_ = addressIPVersion;
+	setParameter("AddressIPVersion", addressIPVersion);
 }
 
 std::string DescribeLoadBalancersRequest::getMasterZoneId()const
@@ -135,39 +91,6 @@ void DescribeLoadBalancersRequest::setPageNumber(int pageNumber)
 	setParameter("PageNumber", std::to_string(pageNumber));
 }
 
-std::string DescribeLoadBalancersRequest::getTags()const
-{
-	return tags_;
-}
-
-void DescribeLoadBalancersRequest::setTags(const std::string& tags)
-{
-	tags_ = tags;
-	setParameter("Tags", tags);
-}
-
-std::string DescribeLoadBalancersRequest::getServerIntranetAddress()const
-{
-	return serverIntranetAddress_;
-}
-
-void DescribeLoadBalancersRequest::setServerIntranetAddress(const std::string& serverIntranetAddress)
-{
-	serverIntranetAddress_ = serverIntranetAddress;
-	setParameter("ServerIntranetAddress", serverIntranetAddress);
-}
-
-std::string DescribeLoadBalancersRequest::getVSwitchId()const
-{
-	return vSwitchId_;
-}
-
-void DescribeLoadBalancersRequest::setVSwitchId(const std::string& vSwitchId)
-{
-	vSwitchId_ = vSwitchId;
-	setParameter("VSwitchId", vSwitchId);
-}
-
 std::string DescribeLoadBalancersRequest::getResourceGroupId()const
 {
 	return resourceGroupId_;
@@ -190,17 +113,6 @@ void DescribeLoadBalancersRequest::setLoadBalancerName(const std::string& loadBa
 	setParameter("LoadBalancerName", loadBalancerName);
 }
 
-std::string DescribeLoadBalancersRequest::getLoadBalancerId()const
-{
-	return loadBalancerId_;
-}
-
-void DescribeLoadBalancersRequest::setLoadBalancerId(const std::string& loadBalancerId)
-{
-	loadBalancerId_ = loadBalancerId;
-	setParameter("LoadBalancerId", loadBalancerId);
-}
-
 std::string DescribeLoadBalancersRequest::getRegionId()const
 {
 	return regionId_;
@@ -212,28 +124,6 @@ void DescribeLoadBalancersRequest::setRegionId(const std::string& regionId)
 	setParameter("RegionId", regionId);
 }
 
-std::string DescribeLoadBalancersRequest::getInternetChargeType()const
-{
-	return internetChargeType_;
-}
-
-void DescribeLoadBalancersRequest::setInternetChargeType(const std::string& internetChargeType)
-{
-	internetChargeType_ = internetChargeType;
-	setParameter("InternetChargeType", internetChargeType);
-}
-
-std::string DescribeLoadBalancersRequest::getVpcId()const
-{
-	return vpcId_;
-}
-
-void DescribeLoadBalancersRequest::setVpcId(const std::string& vpcId)
-{
-	vpcId_ = vpcId;
-	setParameter("VpcId", vpcId);
-}
-
 int DescribeLoadBalancersRequest::getPageSize()const
 {
 	return pageSize_;
@@ -267,6 +157,149 @@ void DescribeLoadBalancersRequest::setSlaveZoneId(const std::string& slaveZoneId
 	setParameter("SlaveZoneId", slaveZoneId);
 }
 
+std::string DescribeLoadBalancersRequest::getFuzzy()const
+{
+	return fuzzy_;
+}
+
+void DescribeLoadBalancersRequest::setFuzzy(const std::string& fuzzy)
+{
+	fuzzy_ = fuzzy;
+	setParameter("Fuzzy", fuzzy);
+}
+
+std::string DescribeLoadBalancersRequest::getAddress()const
+{
+	return address_;
+}
+
+void DescribeLoadBalancersRequest::setAddress(const std::string& address)
+{
+	address_ = address;
+	setParameter("Address", address);
+}
+
+std::string DescribeLoadBalancersRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeLoadBalancersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeLoadBalancersRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeLoadBalancersRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DescribeLoadBalancersRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeLoadBalancersRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeLoadBalancersRequest::getServerId()const
+{
+	return serverId_;
+}
+
+void DescribeLoadBalancersRequest::setServerId(const std::string& serverId)
+{
+	serverId_ = serverId;
+	setParameter("ServerId", serverId);
+}
+
+std::string DescribeLoadBalancersRequest::getLoadBalancerStatus()const
+{
+	return loadBalancerStatus_;
+}
+
+void DescribeLoadBalancersRequest::setLoadBalancerStatus(const std::string& loadBalancerStatus)
+{
+	loadBalancerStatus_ = loadBalancerStatus;
+	setParameter("LoadBalancerStatus", loadBalancerStatus);
+}
+
+std::string DescribeLoadBalancersRequest::getTags()const
+{
+	return tags_;
+}
+
+void DescribeLoadBalancersRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+
+std::string DescribeLoadBalancersRequest::getServerIntranetAddress()const
+{
+	return serverIntranetAddress_;
+}
+
+void DescribeLoadBalancersRequest::setServerIntranetAddress(const std::string& serverIntranetAddress)
+{
+	serverIntranetAddress_ = serverIntranetAddress;
+	setParameter("ServerIntranetAddress", serverIntranetAddress);
+}
+
+std::string DescribeLoadBalancersRequest::getVSwitchId()const
+{
+	return vSwitchId_;
+}
+
+void DescribeLoadBalancersRequest::setVSwitchId(const std::string& vSwitchId)
+{
+	vSwitchId_ = vSwitchId;
+	setParameter("VSwitchId", vSwitchId);
+}
+
+std::string DescribeLoadBalancersRequest::getLoadBalancerId()const
+{
+	return loadBalancerId_;
+}
+
+void DescribeLoadBalancersRequest::setLoadBalancerId(const std::string& loadBalancerId)
+{
+	loadBalancerId_ = loadBalancerId;
+	setParameter("LoadBalancerId", loadBalancerId);
+}
+
+std::string DescribeLoadBalancersRequest::getInternetChargeType()const
+{
+	return internetChargeType_;
+}
+
+void DescribeLoadBalancersRequest::setInternetChargeType(const std::string& internetChargeType)
+{
+	internetChargeType_ = internetChargeType;
+	setParameter("InternetChargeType", internetChargeType);
+}
+
+std::string DescribeLoadBalancersRequest::getVpcId()const
+{
+	return vpcId_;
+}
+
+void DescribeLoadBalancersRequest::setVpcId(const std::string& vpcId)
+{
+	vpcId_ = vpcId;
+	setParameter("VpcId", vpcId);
+}
+
 std::string DescribeLoadBalancersRequest::getPayType()const
 {
 	return payType_;

slb/src/model/DescribeLoadBalancersResult.cc

@@ -40,72 +40,74 @@ void DescribeLoadBalancersResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allLoadBalancers = value["LoadBalancers"]["LoadBalancer"];
-	for (auto value : allLoadBalancers)
-	{
-		LoadBalancer loadBalancersObject;
-		if(!value["LoadBalancerId"].isNull())
-			loadBalancersObject.loadBalancerId = value["LoadBalancerId"].asString();
-		if(!value["LoadBalancerName"].isNull())
-			loadBalancersObject.loadBalancerName = value["LoadBalancerName"].asString();
-		if(!value["LoadBalancerStatus"].isNull())
-			loadBalancersObject.loadBalancerStatus = value["LoadBalancerStatus"].asString();
-		if(!value["Address"].isNull())
-			loadBalancersObject.address = value["Address"].asString();
-		if(!value["AddressType"].isNull())
-			loadBalancersObject.addressType = value["AddressType"].asString();
-		if(!value["RegionId"].isNull())
-			loadBalancersObject.regionId = value["RegionId"].asString();
-		if(!value["RegionIdAlias"].isNull())
-			loadBalancersObject.regionIdAlias = value["RegionIdAlias"].asString();
-		if(!value["VSwitchId"].isNull())
-			loadBalancersObject.vSwitchId = value["VSwitchId"].asString();
-		if(!value["VpcId"].isNull())
-			loadBalancersObject.vpcId = value["VpcId"].asString();
-		if(!value["NetworkType"].isNull())
-			loadBalancersObject.networkType = value["NetworkType"].asString();
-		if(!value["MasterZoneId"].isNull())
-			loadBalancersObject.masterZoneId = value["MasterZoneId"].asString();
-		if(!value["SlaveZoneId"].isNull())
-			loadBalancersObject.slaveZoneId = value["SlaveZoneId"].asString();
-		if(!value["InternetChargeType"].isNull())
-			loadBalancersObject.internetChargeType = value["InternetChargeType"].asString();
-		if(!value["CreateTime"].isNull())
-			loadBalancersObject.createTime = value["CreateTime"].asString();
-		if(!value["CreateTimeStamp"].isNull())
-			loadBalancersObject.createTimeStamp = std::stol(value["CreateTimeStamp"].asString());
-		if(!value["PayType"].isNull())
-			loadBalancersObject.payType = value["PayType"].asString();
-		if(!value["ResourceGroupId"].isNull())
-			loadBalancersObject.resourceGroupId = value["ResourceGroupId"].asString();
-		loadBalancers_.push_back(loadBalancersObject);
-	}
-	if(!value["PageNumber"].isNull())
-		pageNumber_ = std::stoi(value["PageNumber"].asString());
-	if(!value["PageSize"].isNull())
-		pageSize_ = std::stoi(value["PageSize"].asString());
-	if(!value["TotalCount"].isNull())
-		totalCount_ = std::stoi(value["TotalCount"].asString());
+	auto allLoadBalancers = value["LoadBalancers"]["LoadBalancer"];
+	for (auto value : allLoadBalancers)
+	{
+		LoadBalancer loadBalancersObject;
+		if(!value["LoadBalancerId"].isNull())
+			loadBalancersObject.loadBalancerId = value["LoadBalancerId"].asString();
+		if(!value["LoadBalancerName"].isNull())
+			loadBalancersObject.loadBalancerName = value["LoadBalancerName"].asString();
+		if(!value["LoadBalancerStatus"].isNull())
+			loadBalancersObject.loadBalancerStatus = value["LoadBalancerStatus"].asString();
+		if(!value["Address"].isNull())
+			loadBalancersObject.address = value["Address"].asString();
+		if(!value["AddressType"].isNull())
+			loadBalancersObject.addressType = value["AddressType"].asString();
+		if(!value["RegionId"].isNull())
+			loadBalancersObject.regionId = value["RegionId"].asString();
+		if(!value["RegionIdAlias"].isNull())
+			loadBalancersObject.regionIdAlias = value["RegionIdAlias"].asString();
+		if(!value["VSwitchId"].isNull())
+			loadBalancersObject.vSwitchId = value["VSwitchId"].asString();
+		if(!value["VpcId"].isNull())
+			loadBalancersObject.vpcId = value["VpcId"].asString();
+		if(!value["NetworkType"].isNull())
+			loadBalancersObject.networkType = value["NetworkType"].asString();
+		if(!value["MasterZoneId"].isNull())
+			loadBalancersObject.masterZoneId = value["MasterZoneId"].asString();
+		if(!value["SlaveZoneId"].isNull())
+			loadBalancersObject.slaveZoneId = value["SlaveZoneId"].asString();
+		if(!value["InternetChargeType"].isNull())
+			loadBalancersObject.internetChargeType = value["InternetChargeType"].asString();
+		if(!value["CreateTime"].isNull())
+			loadBalancersObject.createTime = value["CreateTime"].asString();
+		if(!value["CreateTimeStamp"].isNull())
+			loadBalancersObject.createTimeStamp = std::stol(value["CreateTimeStamp"].asString());
+		if(!value["PayType"].isNull())
+			loadBalancersObject.payType = value["PayType"].asString();
+		if(!value["ResourceGroupId"].isNull())
+			loadBalancersObject.resourceGroupId = value["ResourceGroupId"].asString();
+		if(!value["AddressIPVersion"].isNull())
+			loadBalancersObject.addressIPVersion = value["AddressIPVersion"].asString();
+		loadBalancers_.push_back(loadBalancersObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
 
 }
 
-int DescribeLoadBalancersResult::getTotalCount()const
-{
-	return totalCount_;
-}
-
-int DescribeLoadBalancersResult::getPageSize()const
-{
-	return pageSize_;
-}
-
-int DescribeLoadBalancersResult::getPageNumber()const
-{
-	return pageNumber_;
-}
-
-std::vector<DescribeLoadBalancersResult::LoadBalancer> DescribeLoadBalancersResult::getLoadBalancers()const
-{
-	return loadBalancers_;
-}
-
+int DescribeLoadBalancersResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeLoadBalancersResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeLoadBalancersResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeLoadBalancersResult::LoadBalancer> DescribeLoadBalancersResult::getLoadBalancers()const
+{
+	return loadBalancers_;
+}
+

slb/src/model/DescribeMasterSlaveServerGroupAttributeResult.cc

@@ -40,39 +40,47 @@ void DescribeMasterSlaveServerGroupAttributeResult::parse(const std::string &pay
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allMasterSlaveBackendServers = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
-	for (auto value : allMasterSlaveBackendServers)
-	{
-		MasterSlaveBackendServer masterSlaveBackendServersObject;
-		if(!value["ServerId"].isNull())
-			masterSlaveBackendServersObject.serverId = value["ServerId"].asString();
-		if(!value["Port"].isNull())
-			masterSlaveBackendServersObject.port = std::stoi(value["Port"].asString());
-		if(!value["Weight"].isNull())
-			masterSlaveBackendServersObject.weight = std::stoi(value["Weight"].asString());
-		if(!value["ServerType"].isNull())
-			masterSlaveBackendServersObject.serverType = value["ServerType"].asString();
-		masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
-	}
-	if(!value["MasterSlaveServerGroupId"].isNull())
-		masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
-	if(!value["MasterSlaveServerGroupName"].isNull())
-		masterSlaveServerGroupName_ = value["MasterSlaveServerGroupName"].asString();
+	auto allMasterSlaveBackendServers = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
+	for (auto value : allMasterSlaveBackendServers)
+	{
+		MasterSlaveBackendServer masterSlaveBackendServersObject;
+		if(!value["ServerId"].isNull())
+			masterSlaveBackendServersObject.serverId = value["ServerId"].asString();
+		if(!value["Port"].isNull())
+			masterSlaveBackendServersObject.port = std::stoi(value["Port"].asString());
+		if(!value["Weight"].isNull())
+			masterSlaveBackendServersObject.weight = std::stoi(value["Weight"].asString());
+		if(!value["ServerType"].isNull())
+			masterSlaveBackendServersObject.serverType = value["ServerType"].asString();
+		if(!value["Type"].isNull())
+			masterSlaveBackendServersObject.type = value["Type"].asString();
+		if(!value["ServerIp"].isNull())
+			masterSlaveBackendServersObject.serverIp = value["ServerIp"].asString();
+		if(!value["EniHost"].isNull())
+			masterSlaveBackendServersObject.eniHost = value["EniHost"].asString();
+		if(!value["VpcId"].isNull())
+			masterSlaveBackendServersObject.vpcId = value["VpcId"].asString();
+		masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
+	}
+	if(!value["MasterSlaveServerGroupId"].isNull())
+		masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
+	if(!value["MasterSlaveServerGroupName"].isNull())
+		masterSlaveServerGroupName_ = value["MasterSlaveServerGroupName"].asString();
 
 }
 
-std::string DescribeMasterSlaveServerGroupAttributeResult::getMasterSlaveServerGroupId()const
-{
-	return masterSlaveServerGroupId_;
-}
-
-std::string DescribeMasterSlaveServerGroupAttributeResult::getMasterSlaveServerGroupName()const
-{
-	return masterSlaveServerGroupName_;
-}
-
-std::vector<DescribeMasterSlaveServerGroupAttributeResult::MasterSlaveBackendServer> DescribeMasterSlaveServerGroupAttributeResult::getMasterSlaveBackendServers()const
-{
-	return masterSlaveBackendServers_;
-}
-
+std::string DescribeMasterSlaveServerGroupAttributeResult::getMasterSlaveServerGroupId()const
+{
+	return masterSlaveServerGroupId_;
+}
+
+std::string DescribeMasterSlaveServerGroupAttributeResult::getMasterSlaveServerGroupName()const
+{
+	return masterSlaveServerGroupName_;
+}
+
+std::vector<DescribeMasterSlaveServerGroupAttributeResult::MasterSlaveBackendServer> DescribeMasterSlaveServerGroupAttributeResult::getMasterSlaveBackendServers()const
+{
+	return masterSlaveBackendServers_;
+}
+

slb/src/model/DescribeMasterSlaveServerGroupsRequest.cc

@@ -80,6 +80,17 @@ void DescribeMasterSlaveServerGroupsRequest::setRegionId(const std::string& regi
 	setParameter("RegionId", regionId);
 }
 
+bool DescribeMasterSlaveServerGroupsRequest::getIncludeListener()const
+{
+	return includeListener_;
+}
+
+void DescribeMasterSlaveServerGroupsRequest::setIncludeListener(bool includeListener)
+{
+	includeListener_ = includeListener;
+	setParameter("IncludeListener", std::to_string(includeListener));
+}
+
 std::string DescribeMasterSlaveServerGroupsRequest::getOwnerAccount()const
 {
 	return ownerAccount_;

slb/src/model/DescribeMasterSlaveServerGroupsResult.cc

@@ -40,21 +40,32 @@ void DescribeMasterSlaveServerGroupsResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allMasterSlaveServerGroups = value["MasterSlaveServerGroups"]["MasterSlaveServerGroup"];
-	for (auto value : allMasterSlaveServerGroups)
-	{
-		MasterSlaveServerGroup masterSlaveServerGroupsObject;
-		if(!value["MasterSlaveServerGroupId"].isNull())
-			masterSlaveServerGroupsObject.masterSlaveServerGroupId = value["MasterSlaveServerGroupId"].asString();
-		if(!value["MasterSlaveServerGroupName"].isNull())
-			masterSlaveServerGroupsObject.masterSlaveServerGroupName = value["MasterSlaveServerGroupName"].asString();
-		masterSlaveServerGroups_.push_back(masterSlaveServerGroupsObject);
-	}
+	auto allMasterSlaveServerGroups = value["MasterSlaveServerGroups"]["MasterSlaveServerGroup"];
+	for (auto value : allMasterSlaveServerGroups)
+	{
+		MasterSlaveServerGroup masterSlaveServerGroupsObject;
+		if(!value["MasterSlaveServerGroupId"].isNull())
+			masterSlaveServerGroupsObject.masterSlaveServerGroupId = value["MasterSlaveServerGroupId"].asString();
+		if(!value["MasterSlaveServerGroupName"].isNull())
+			masterSlaveServerGroupsObject.masterSlaveServerGroupName = value["MasterSlaveServerGroupName"].asString();
+		auto associatedObjectsNode = value["AssociatedObjects"];
+		auto allListeners = value["Listeners"]["Listener"];
+		for (auto value : allListeners)
+		{
+			MasterSlaveServerGroup::AssociatedObjects::Listener listenerObject;
+			if(!value["Protocol"].isNull())
+				listenerObject.protocol = value["Protocol"].asString();
+			if(!value["Port"].isNull())
+				listenerObject.port = std::stoi(value["Port"].asString());
+			masterSlaveServerGroupsObject.associatedObjects.listeners.push_back(listenerObject);
+		}
+		masterSlaveServerGroups_.push_back(masterSlaveServerGroupsObject);
+	}
 
 }
 
-std::vector<DescribeMasterSlaveServerGroupsResult::MasterSlaveServerGroup> DescribeMasterSlaveServerGroupsResult::getMasterSlaveServerGroups()const
-{
-	return masterSlaveServerGroups_;
-}
-
+std::vector<DescribeMasterSlaveServerGroupsResult::MasterSlaveServerGroup> DescribeMasterSlaveServerGroupsResult::getMasterSlaveServerGroups()const
+{
+	return masterSlaveServerGroups_;
+}
+

slb/src/model/DescribeMasterSlaveVServerGroupAttributeResult.cc

@@ -40,39 +40,47 @@ void DescribeMasterSlaveVServerGroupAttributeResult::parse(const std::string &pa
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allMasterSlaveBackendServers = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
-	for (auto value : allMasterSlaveBackendServers)
-	{
-		MasterSlaveBackendServer masterSlaveBackendServersObject;
-		if(!value["ServerId"].isNull())
-			masterSlaveBackendServersObject.serverId = value["ServerId"].asString();
-		if(!value["Port"].isNull())
-			masterSlaveBackendServersObject.port = std::stoi(value["Port"].asString());
-		if(!value["Weight"].isNull())
-			masterSlaveBackendServersObject.weight = std::stoi(value["Weight"].asString());
-		if(!value["IsBackup"].isNull())
-			masterSlaveBackendServersObject.isBackup = std::stoi(value["IsBackup"].asString());
-		masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
-	}
-	if(!value["MasterSlaveVServerGroupId"].isNull())
-		masterSlaveVServerGroupId_ = value["MasterSlaveVServerGroupId"].asString();
-	if(!value["MasterSlaveVServerGroupName"].isNull())
-		masterSlaveVServerGroupName_ = value["MasterSlaveVServerGroupName"].asString();
+	auto allMasterSlaveBackendServers = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
+	for (auto value : allMasterSlaveBackendServers)
+	{
+		MasterSlaveBackendServer masterSlaveBackendServersObject;
+		if(!value["ServerId"].isNull())
+			masterSlaveBackendServersObject.serverId = value["ServerId"].asString();
+		if(!value["Port"].isNull())
+			masterSlaveBackendServersObject.port = std::stoi(value["Port"].asString());
+		if(!value["Weight"].isNull())
+			masterSlaveBackendServersObject.weight = std::stoi(value["Weight"].asString());
+		if(!value["IsBackup"].isNull())
+			masterSlaveBackendServersObject.isBackup = std::stoi(value["IsBackup"].asString());
+		if(!value["Type"].isNull())
+			masterSlaveBackendServersObject.type = value["Type"].asString();
+		if(!value["ServerIp"].isNull())
+			masterSlaveBackendServersObject.serverIp = value["ServerIp"].asString();
+		if(!value["EniHost"].isNull())
+			masterSlaveBackendServersObject.eniHost = value["EniHost"].asString();
+		if(!value["VpcId"].isNull())
+			masterSlaveBackendServersObject.vpcId = value["VpcId"].asString();
+		masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
+	}
+	if(!value["MasterSlaveVServerGroupId"].isNull())
+		masterSlaveVServerGroupId_ = value["MasterSlaveVServerGroupId"].asString();
+	if(!value["MasterSlaveVServerGroupName"].isNull())
+		masterSlaveVServerGroupName_ = value["MasterSlaveVServerGroupName"].asString();
 
 }
 
-std::string DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveVServerGroupId()const
-{
-	return masterSlaveVServerGroupId_;
-}
-
-std::vector<DescribeMasterSlaveVServerGroupAttributeResult::MasterSlaveBackendServer> DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveBackendServers()const
-{
-	return masterSlaveBackendServers_;
-}
-
-std::string DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveVServerGroupName()const
-{
-	return masterSlaveVServerGroupName_;
-}
-
+std::string DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveVServerGroupId()const
+{
+	return masterSlaveVServerGroupId_;
+}
+
+std::vector<DescribeMasterSlaveVServerGroupAttributeResult::MasterSlaveBackendServer> DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveBackendServers()const
+{
+	return masterSlaveBackendServers_;
+}
+
+std::string DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveVServerGroupName()const
+{
+	return masterSlaveVServerGroupName_;
+}
+

slb/src/model/DescribeMasterSlaveVServerGroupsResult.cc

@@ -40,21 +40,21 @@ void DescribeMasterSlaveVServerGroupsResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allMasterSlaveVServerGroups = value["MasterSlaveVServerGroups"]["MasterSlaveVServerGroup"];
-	for (auto value : allMasterSlaveVServerGroups)
-	{
-		MasterSlaveVServerGroup masterSlaveVServerGroupsObject;
-		if(!value["MasterSlaveVServerGroupId"].isNull())
-			masterSlaveVServerGroupsObject.masterSlaveVServerGroupId = value["MasterSlaveVServerGroupId"].asString();
-		if(!value["MasterSlaveVServerGroupName"].isNull())
-			masterSlaveVServerGroupsObject.masterSlaveVServerGroupName = value["MasterSlaveVServerGroupName"].asString();
-		masterSlaveVServerGroups_.push_back(masterSlaveVServerGroupsObject);
-	}
+	auto allMasterSlaveVServerGroups = value["MasterSlaveVServerGroups"]["MasterSlaveVServerGroup"];
+	for (auto value : allMasterSlaveVServerGroups)
+	{
+		MasterSlaveVServerGroup masterSlaveVServerGroupsObject;
+		if(!value["MasterSlaveVServerGroupId"].isNull())
+			masterSlaveVServerGroupsObject.masterSlaveVServerGroupId = value["MasterSlaveVServerGroupId"].asString();
+		if(!value["MasterSlaveVServerGroupName"].isNull())
+			masterSlaveVServerGroupsObject.masterSlaveVServerGroupName = value["MasterSlaveVServerGroupName"].asString();
+		masterSlaveVServerGroups_.push_back(masterSlaveVServerGroupsObject);
+	}
 
 }
 
-std::vector<DescribeMasterSlaveVServerGroupsResult::MasterSlaveVServerGroup> DescribeMasterSlaveVServerGroupsResult::getMasterSlaveVServerGroups()const
-{
-	return masterSlaveVServerGroups_;
-}
-
+std::vector<DescribeMasterSlaveVServerGroupsResult::MasterSlaveVServerGroup> DescribeMasterSlaveVServerGroupsResult::getMasterSlaveVServerGroups()const
+{
+	return masterSlaveVServerGroups_;
+}
+

slb/src/model/DescribeRegionsRequest.cc

@@ -80,6 +80,17 @@ void DescribeRegionsRequest::setOwnerAccount(const std::string& ownerAccount)
 	setParameter("OwnerAccount", ownerAccount);
 }
 
+std::string DescribeRegionsRequest::getAcceptLanguage()const
+{
+	return acceptLanguage_;
+}
+
+void DescribeRegionsRequest::setAcceptLanguage(const std::string& acceptLanguage)
+{
+	acceptLanguage_ = acceptLanguage;
+	setParameter("AcceptLanguage", acceptLanguage);
+}
+
 long DescribeRegionsRequest::getOwnerId()const
 {
 	return ownerId_;

slb/src/model/DescribeRegionsResult.cc

@@ -40,21 +40,23 @@ void DescribeRegionsResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allRegions = value["Regions"]["Region"];
-	for (auto value : allRegions)
-	{
-		Region regionsObject;
-		if(!value["RegionId"].isNull())
-			regionsObject.regionId = value["RegionId"].asString();
-		if(!value["LocalName"].isNull())
-			regionsObject.localName = value["LocalName"].asString();
-		regions_.push_back(regionsObject);
-	}
+	auto allRegions = value["Regions"]["Region"];
+	for (auto value : allRegions)
+	{
+		Region regionsObject;
+		if(!value["RegionId"].isNull())
+			regionsObject.regionId = value["RegionId"].asString();
+		if(!value["LocalName"].isNull())
+			regionsObject.localName = value["LocalName"].asString();
+		if(!value["RegionEndpoint"].isNull())
+			regionsObject.regionEndpoint = value["RegionEndpoint"].asString();
+		regions_.push_back(regionsObject);
+	}
 
 }
 
-std::vector<DescribeRegionsResult::Region> DescribeRegionsResult::getRegions()const
-{
-	return regions_;
-}
-
+std::vector<DescribeRegionsResult::Region> DescribeRegionsResult::getRegions()const
+{
+	return regions_;
+}
+

slb/src/model/DescribeRuleAttributeResult.cc

@@ -40,48 +40,153 @@ void DescribeRuleAttributeResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["RuleName"].isNull())
-		ruleName_ = value["RuleName"].asString();
-	if(!value["LoadBalancerId"].isNull())
-		loadBalancerId_ = value["LoadBalancerId"].asString();
-	if(!value["ListenerPort"].isNull())
-		listenerPort_ = value["ListenerPort"].asString();
-	if(!value["Domain"].isNull())
-		domain_ = value["Domain"].asString();
-	if(!value["Url"].isNull())
-		url_ = value["Url"].asString();
-	if(!value["VServerGroupId"].isNull())
-		vServerGroupId_ = value["VServerGroupId"].asString();
+	if(!value["RuleName"].isNull())
+		ruleName_ = value["RuleName"].asString();
+	if(!value["LoadBalancerId"].isNull())
+		loadBalancerId_ = value["LoadBalancerId"].asString();
+	if(!value["ListenerPort"].isNull())
+		listenerPort_ = value["ListenerPort"].asString();
+	if(!value["Domain"].isNull())
+		domain_ = value["Domain"].asString();
+	if(!value["Url"].isNull())
+		url_ = value["Url"].asString();
+	if(!value["VServerGroupId"].isNull())
+		vServerGroupId_ = value["VServerGroupId"].asString();
+	if(!value["ListenerSync"].isNull())
+		listenerSync_ = value["ListenerSync"].asString();
+	if(!value["Scheduler"].isNull())
+		scheduler_ = value["Scheduler"].asString();
+	if(!value["StickySession"].isNull())
+		stickySession_ = value["StickySession"].asString();
+	if(!value["StickySessionType"].isNull())
+		stickySessionType_ = value["StickySessionType"].asString();
+	if(!value["CookieTimeout"].isNull())
+		cookieTimeout_ = std::stoi(value["CookieTimeout"].asString());
+	if(!value["Cookie"].isNull())
+		cookie_ = value["Cookie"].asString();
+	if(!value["HealthCheck"].isNull())
+		healthCheck_ = value["HealthCheck"].asString();
+	if(!value["HealthCheckDomain"].isNull())
+		healthCheckDomain_ = value["HealthCheckDomain"].asString();
+	if(!value["HealthCheckURI"].isNull())
+		healthCheckURI_ = value["HealthCheckURI"].asString();
+	if(!value["HealthyThreshold"].isNull())
+		healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
+	if(!value["UnhealthyThreshold"].isNull())
+		unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
+	if(!value["HealthCheckTimeout"].isNull())
+		healthCheckTimeout_ = std::stoi(value["HealthCheckTimeout"].asString());
+	if(!value["HealthCheckInterval"].isNull())
+		healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
+	if(!value["HealthCheckConnectPort"].isNull())
+		healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
+	if(!value["HealthCheckHttpCode"].isNull())
+		healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
 
 }
 
-std::string DescribeRuleAttributeResult::getListenerPort()const
-{
-	return listenerPort_;
-}
-
-std::string DescribeRuleAttributeResult::getVServerGroupId()const
-{
-	return vServerGroupId_;
-}
-
-std::string DescribeRuleAttributeResult::getLoadBalancerId()const
-{
-	return loadBalancerId_;
-}
-
-std::string DescribeRuleAttributeResult::getDomain()const
-{
-	return domain_;
-}
-
-std::string DescribeRuleAttributeResult::getRuleName()const
-{
-	return ruleName_;
-}
-
-std::string DescribeRuleAttributeResult::getUrl()const
-{
-	return url_;
-}
-
+int DescribeRuleAttributeResult::getCookieTimeout()const
+{
+	return cookieTimeout_;
+}
+
+std::string DescribeRuleAttributeResult::getCookie()const
+{
+	return cookie_;
+}
+
+std::string DescribeRuleAttributeResult::getListenerPort()const
+{
+	return listenerPort_;
+}
+
+std::string DescribeRuleAttributeResult::getVServerGroupId()const
+{
+	return vServerGroupId_;
+}
+
+int DescribeRuleAttributeResult::getHealthCheckInterval()const
+{
+	return healthCheckInterval_;
+}
+
+int DescribeRuleAttributeResult::getUnhealthyThreshold()const
+{
+	return unhealthyThreshold_;
+}
+
+std::string DescribeRuleAttributeResult::getScheduler()const
+{
+	return scheduler_;
+}
+
+std::string DescribeRuleAttributeResult::getHealthCheckURI()const
+{
+	return healthCheckURI_;
+}
+
+std::string DescribeRuleAttributeResult::getHealthCheck()const
+{
+	return healthCheck_;
+}
+
+std::string DescribeRuleAttributeResult::getLoadBalancerId()const
+{
+	return loadBalancerId_;
+}
+
+int DescribeRuleAttributeResult::getHealthCheckTimeout()const
+{
+	return healthCheckTimeout_;
+}
+
+std::string DescribeRuleAttributeResult::getUrl()const
+{
+	return url_;
+}
+
+std::string DescribeRuleAttributeResult::getStickySession()const
+{
+	return stickySession_;
+}
+
+int DescribeRuleAttributeResult::getHealthCheckConnectPort()const
+{
+	return healthCheckConnectPort_;
+}
+
+int DescribeRuleAttributeResult::getHealthyThreshold()const
+{
+	return healthyThreshold_;
+}
+
+std::string DescribeRuleAttributeResult::getListenerSync()const
+{
+	return listenerSync_;
+}
+
+std::string DescribeRuleAttributeResult::getHealthCheckDomain()const
+{
+	return healthCheckDomain_;
+}
+
+std::string DescribeRuleAttributeResult::getStickySessionType()const
+{
+	return stickySessionType_;
+}
+
+std::string DescribeRuleAttributeResult::getDomain()const
+{
+	return domain_;
+}
+
+std::string DescribeRuleAttributeResult::getHealthCheckHttpCode()const
+{
+	return healthCheckHttpCode_;
+}
+
+std::string DescribeRuleAttributeResult::getRuleName()const
+{
+	return ruleName_;
+}
+

slb/src/model/DescribeRulesResult.cc

@@ -40,27 +40,57 @@ void DescribeRulesResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allRules = value["Rules"]["Rule"];
-	for (auto value : allRules)
-	{
-		Rule rulesObject;
-		if(!value["RuleId"].isNull())
-			rulesObject.ruleId = value["RuleId"].asString();
-		if(!value["RuleName"].isNull())
-			rulesObject.ruleName = value["RuleName"].asString();
-		if(!value["Domain"].isNull())
-			rulesObject.domain = value["Domain"].asString();
-		if(!value["Url"].isNull())
-			rulesObject.url = value["Url"].asString();
-		if(!value["VServerGroupId"].isNull())
-			rulesObject.vServerGroupId = value["VServerGroupId"].asString();
-		rules_.push_back(rulesObject);
-	}
+	auto allRules = value["Rules"]["Rule"];
+	for (auto value : allRules)
+	{
+		Rule rulesObject;
+		if(!value["RuleId"].isNull())
+			rulesObject.ruleId = value["RuleId"].asString();
+		if(!value["RuleName"].isNull())
+			rulesObject.ruleName = value["RuleName"].asString();
+		if(!value["Domain"].isNull())
+			rulesObject.domain = value["Domain"].asString();
+		if(!value["Url"].isNull())
+			rulesObject.url = value["Url"].asString();
+		if(!value["VServerGroupId"].isNull())
+			rulesObject.vServerGroupId = value["VServerGroupId"].asString();
+		if(!value["ListenerSync"].isNull())
+			rulesObject.listenerSync = value["ListenerSync"].asString();
+		if(!value["Scheduler"].isNull())
+			rulesObject.scheduler = value["Scheduler"].asString();
+		if(!value["StickySession"].isNull())
+			rulesObject.stickySession = value["StickySession"].asString();
+		if(!value["StickySessionType"].isNull())
+			rulesObject.stickySessionType = value["StickySessionType"].asString();
+		if(!value["CookieTimeout"].isNull())
+			rulesObject.cookieTimeout = std::stoi(value["CookieTimeout"].asString());
+		if(!value["Cookie"].isNull())
+			rulesObject.cookie = value["Cookie"].asString();
+		if(!value["HealthCheck"].isNull())
+			rulesObject.healthCheck = value["HealthCheck"].asString();
+		if(!value["HealthCheckDomain"].isNull())
+			rulesObject.healthCheckDomain = value["HealthCheckDomain"].asString();
+		if(!value["HealthCheckURI"].isNull())
+			rulesObject.healthCheckURI = value["HealthCheckURI"].asString();
+		if(!value["HealthyThreshold"].isNull())
+			rulesObject.healthyThreshold = std::stoi(value["HealthyThreshold"].asString());
+		if(!value["UnhealthyThreshold"].isNull())
+			rulesObject.unhealthyThreshold = std::stoi(value["UnhealthyThreshold"].asString());
+		if(!value["HealthCheckTimeout"].isNull())
+			rulesObject.healthCheckTimeout = std::stoi(value["HealthCheckTimeout"].asString());
+		if(!value["HealthCheckInterval"].isNull())
+			rulesObject.healthCheckInterval = std::stoi(value["HealthCheckInterval"].asString());
+		if(!value["HealthCheckConnectPort"].isNull())
+			rulesObject.healthCheckConnectPort = std::stoi(value["HealthCheckConnectPort"].asString());
+		if(!value["HealthCheckHttpCode"].isNull())
+			rulesObject.healthCheckHttpCode = value["HealthCheckHttpCode"].asString();
+		rules_.push_back(rulesObject);
+	}
 
 }
 
-std::vector<DescribeRulesResult::Rule> DescribeRulesResult::getRules()const
-{
-	return rules_;
-}
-
+std::vector<DescribeRulesResult::Rule> DescribeRulesResult::getRules()const
+{
+	return rules_;
+}
+

slb/src/model/DescribeServerCertificatesResult.cc

@@ -40,39 +40,48 @@ void DescribeServerCertificatesResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allServerCertificates = value["ServerCertificates"]["ServerCertificate"];
-	for (auto value : allServerCertificates)
-	{
-		ServerCertificate serverCertificatesObject;
-		if(!value["ServerCertificateId"].isNull())
-			serverCertificatesObject.serverCertificateId = value["ServerCertificateId"].asString();
-		if(!value["Fingerprint"].isNull())
-			serverCertificatesObject.fingerprint = value["Fingerprint"].asString();
-		if(!value["ServerCertificateName"].isNull())
-			serverCertificatesObject.serverCertificateName = value["ServerCertificateName"].asString();
-		if(!value["RegionId"].isNull())
-			serverCertificatesObject.regionId = value["RegionId"].asString();
-		if(!value["RegionIdAlias"].isNull())
-			serverCertificatesObject.regionIdAlias = value["RegionIdAlias"].asString();
-		if(!value["AliCloudCertificateId"].isNull())
-			serverCertificatesObject.aliCloudCertificateId = value["AliCloudCertificateId"].asString();
-		if(!value["AliCloudCertificateName"].isNull())
-			serverCertificatesObject.aliCloudCertificateName = value["AliCloudCertificateName"].asString();
-		if(!value["IsAliCloudCertificate"].isNull())
-			serverCertificatesObject.isAliCloudCertificate = std::stoi(value["IsAliCloudCertificate"].asString());
-		if(!value["ResourceGroupId"].isNull())
-			serverCertificatesObject.resourceGroupId = value["ResourceGroupId"].asString();
-		if(!value["CreateTime"].isNull())
-			serverCertificatesObject.createTime = value["CreateTime"].asString();
-		if(!value["CreateTimeStamp"].isNull())
-			serverCertificatesObject.createTimeStamp = std::stol(value["CreateTimeStamp"].asString());
-		serverCertificates_.push_back(serverCertificatesObject);
-	}
+	auto allServerCertificates = value["ServerCertificates"]["ServerCertificate"];
+	for (auto value : allServerCertificates)
+	{
+		ServerCertificate serverCertificatesObject;
+		if(!value["ServerCertificateId"].isNull())
+			serverCertificatesObject.serverCertificateId = value["ServerCertificateId"].asString();
+		if(!value["Fingerprint"].isNull())
+			serverCertificatesObject.fingerprint = value["Fingerprint"].asString();
+		if(!value["ServerCertificateName"].isNull())
+			serverCertificatesObject.serverCertificateName = value["ServerCertificateName"].asString();
+		if(!value["RegionId"].isNull())
+			serverCertificatesObject.regionId = value["RegionId"].asString();
+		if(!value["RegionIdAlias"].isNull())
+			serverCertificatesObject.regionIdAlias = value["RegionIdAlias"].asString();
+		if(!value["AliCloudCertificateId"].isNull())
+			serverCertificatesObject.aliCloudCertificateId = value["AliCloudCertificateId"].asString();
+		if(!value["AliCloudCertificateName"].isNull())
+			serverCertificatesObject.aliCloudCertificateName = value["AliCloudCertificateName"].asString();
+		if(!value["IsAliCloudCertificate"].isNull())
+			serverCertificatesObject.isAliCloudCertificate = std::stoi(value["IsAliCloudCertificate"].asString());
+		if(!value["ResourceGroupId"].isNull())
+			serverCertificatesObject.resourceGroupId = value["ResourceGroupId"].asString();
+		if(!value["CreateTime"].isNull())
+			serverCertificatesObject.createTime = value["CreateTime"].asString();
+		if(!value["CreateTimeStamp"].isNull())
+			serverCertificatesObject.createTimeStamp = std::stol(value["CreateTimeStamp"].asString());
+		if(!value["ExpireTime"].isNull())
+			serverCertificatesObject.expireTime = value["ExpireTime"].asString();
+		if(!value["ExpireTimeStamp"].isNull())
+			serverCertificatesObject.expireTimeStamp = std::stol(value["ExpireTimeStamp"].asString());
+		if(!value["CommonName"].isNull())
+			serverCertificatesObject.commonName = value["CommonName"].asString();
+		auto allSubjectAlternativeNames = value["SubjectAlternativeNames"]["SubjectAlternativeName"];
+		for (auto value : allSubjectAlternativeNames)
+			serverCertificatesObject.subjectAlternativeNames.push_back(value.asString());
+		serverCertificates_.push_back(serverCertificatesObject);
+	}
 
 }
 
-std::vector<DescribeServerCertificatesResult::ServerCertificate> DescribeServerCertificatesResult::getServerCertificates()const
-{
-	return serverCertificates_;
-}
-
+std::vector<DescribeServerCertificatesResult::ServerCertificate> DescribeServerCertificatesResult::getServerCertificates()const
+{
+	return serverCertificates_;
+}
+

slb/src/model/DescribeSlbQuotasRequest.cc

@@ -0,0 +1,104 @@
+/*
+ * 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/slb/model/DescribeSlbQuotasRequest.h>
+
+using AlibabaCloud::Slb::Model::DescribeSlbQuotasRequest;
+
+DescribeSlbQuotasRequest::DescribeSlbQuotasRequest() :
+	RpcServiceRequest("slb", "2014-05-15", "DescribeSlbQuotas")
+{}
+
+DescribeSlbQuotasRequest::~DescribeSlbQuotasRequest()
+{}
+
+std::string DescribeSlbQuotasRequest::getAccess_key_id()const
+{
+	return access_key_id_;
+}
+
+void DescribeSlbQuotasRequest::setAccess_key_id(const std::string& access_key_id)
+{
+	access_key_id_ = access_key_id;
+	setParameter("Access_key_id", access_key_id);
+}
+
+long DescribeSlbQuotasRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeSlbQuotasRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeSlbQuotasRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeSlbQuotasRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DescribeSlbQuotasRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeSlbQuotasRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeSlbQuotasRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeSlbQuotasRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DescribeSlbQuotasRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeSlbQuotasRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeSlbQuotasRequest::getTags()const
+{
+	return tags_;
+}
+
+void DescribeSlbQuotasRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+

slb/src/model/DescribeSlbQuotasResult.cc

@@ -0,0 +1,62 @@
+/*
+ * 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/slb/model/DescribeSlbQuotasResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DescribeSlbQuotasResult::DescribeSlbQuotasResult() :
+	ServiceResult()
+{}
+
+DescribeSlbQuotasResult::DescribeSlbQuotasResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeSlbQuotasResult::~DescribeSlbQuotasResult()
+{}
+
+void DescribeSlbQuotasResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allQuotas = value["Quotas"]["Quota"];
+	for (auto value : allQuotas)
+	{
+		Quota quotasObject;
+		if(!value["Max"].isNull())
+			quotasObject.max = value["Max"].asString();
+		if(!value["QuotaName"].isNull())
+			quotasObject.quotaName = value["QuotaName"].asString();
+		if(!value["Comment"].isNull())
+			quotasObject.comment = value["Comment"].asString();
+		quotas_.push_back(quotasObject);
+	}
+
+}
+
+std::vector<DescribeSlbQuotasResult::Quota> DescribeSlbQuotasResult::getQuotas()const
+{
+	return quotas_;
+}
+

slb/src/model/DescribeTagsResult.cc

@@ -40,44 +40,44 @@ void DescribeTagsResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allTagSets = value["TagSets"]["TagSet"];
-	for (auto value : allTagSets)
-	{
-		TagSet tagSetsObject;
-		if(!value["TagKey"].isNull())
-			tagSetsObject.tagKey = value["TagKey"].asString();
-		if(!value["TagValue"].isNull())
-			tagSetsObject.tagValue = value["TagValue"].asString();
-		if(!value["InstanceCount"].isNull())
-			tagSetsObject.instanceCount = std::stoi(value["InstanceCount"].asString());
-		tagSets_.push_back(tagSetsObject);
-	}
-	if(!value["PageSize"].isNull())
-		pageSize_ = std::stoi(value["PageSize"].asString());
-	if(!value["PageNumber"].isNull())
-		pageNumber_ = std::stoi(value["PageNumber"].asString());
-	if(!value["TotalCount"].isNull())
-		totalCount_ = std::stoi(value["TotalCount"].asString());
+	auto allTagSets = value["TagSets"]["TagSet"];
+	for (auto value : allTagSets)
+	{
+		TagSet tagSetsObject;
+		if(!value["TagKey"].isNull())
+			tagSetsObject.tagKey = value["TagKey"].asString();
+		if(!value["TagValue"].isNull())
+			tagSetsObject.tagValue = value["TagValue"].asString();
+		if(!value["InstanceCount"].isNull())
+			tagSetsObject.instanceCount = std::stoi(value["InstanceCount"].asString());
+		tagSets_.push_back(tagSetsObject);
+	}
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
 
 }
 
-int DescribeTagsResult::getTotalCount()const
-{
-	return totalCount_;
-}
-
-int DescribeTagsResult::getPageSize()const
-{
-	return pageSize_;
-}
-
-int DescribeTagsResult::getPageNumber()const
-{
-	return pageNumber_;
-}
-
-std::vector<DescribeTagsResult::TagSet> DescribeTagsResult::getTagSets()const
-{
-	return tagSets_;
-}
-
+int DescribeTagsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeTagsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeTagsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeTagsResult::TagSet> DescribeTagsResult::getTagSets()const
+{
+	return tagSets_;
+}
+

slb/src/model/DescribeVServerGroupAttributeResult.cc

@@ -40,37 +40,45 @@ void DescribeVServerGroupAttributeResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allBackendServers = value["BackendServers"]["BackendServer"];
-	for (auto value : allBackendServers)
-	{
-		BackendServer backendServersObject;
-		if(!value["ServerId"].isNull())
-			backendServersObject.serverId = value["ServerId"].asString();
-		if(!value["Port"].isNull())
-			backendServersObject.port = std::stoi(value["Port"].asString());
-		if(!value["Weight"].isNull())
-			backendServersObject.weight = std::stoi(value["Weight"].asString());
-		backendServers_.push_back(backendServersObject);
-	}
-	if(!value["VServerGroupId"].isNull())
-		vServerGroupId_ = value["VServerGroupId"].asString();
-	if(!value["VServerGroupName"].isNull())
-		vServerGroupName_ = value["VServerGroupName"].asString();
+	auto allBackendServers = value["BackendServers"]["BackendServer"];
+	for (auto value : allBackendServers)
+	{
+		BackendServer backendServersObject;
+		if(!value["ServerId"].isNull())
+			backendServersObject.serverId = value["ServerId"].asString();
+		if(!value["Port"].isNull())
+			backendServersObject.port = std::stoi(value["Port"].asString());
+		if(!value["Weight"].isNull())
+			backendServersObject.weight = std::stoi(value["Weight"].asString());
+		if(!value["Type"].isNull())
+			backendServersObject.type = value["Type"].asString();
+		if(!value["ServerIp"].isNull())
+			backendServersObject.serverIp = value["ServerIp"].asString();
+		if(!value["EniHost"].isNull())
+			backendServersObject.eniHost = value["EniHost"].asString();
+		if(!value["VpcId"].isNull())
+			backendServersObject.vpcId = value["VpcId"].asString();
+		backendServers_.push_back(backendServersObject);
+	}
+	if(!value["VServerGroupId"].isNull())
+		vServerGroupId_ = value["VServerGroupId"].asString();
+	if(!value["VServerGroupName"].isNull())
+		vServerGroupName_ = value["VServerGroupName"].asString();
 
 }
 
-std::string DescribeVServerGroupAttributeResult::getVServerGroupId()const
-{
-	return vServerGroupId_;
-}
-
-std::string DescribeVServerGroupAttributeResult::getVServerGroupName()const
-{
-	return vServerGroupName_;
-}
-
-std::vector<DescribeVServerGroupAttributeResult::BackendServer> DescribeVServerGroupAttributeResult::getBackendServers()const
-{
-	return backendServers_;
-}
-
+std::string DescribeVServerGroupAttributeResult::getVServerGroupId()const
+{
+	return vServerGroupId_;
+}
+
+std::string DescribeVServerGroupAttributeResult::getVServerGroupName()const
+{
+	return vServerGroupName_;
+}
+
+std::vector<DescribeVServerGroupAttributeResult::BackendServer> DescribeVServerGroupAttributeResult::getBackendServers()const
+{
+	return backendServers_;
+}
+

slb/src/model/DescribeVServerGroupsRequest.cc

@@ -36,6 +36,17 @@ void DescribeVServerGroupsRequest::setAccess_key_id(const std::string& access_ke
 	setParameter("Access_key_id", access_key_id);
 }
 
+bool DescribeVServerGroupsRequest::getIncludeRule()const
+{
+	return includeRule_;
+}
+
+void DescribeVServerGroupsRequest::setIncludeRule(bool includeRule)
+{
+	includeRule_ = includeRule;
+	setParameter("IncludeRule", std::to_string(includeRule));
+}
+
 long DescribeVServerGroupsRequest::getResourceOwnerId()const
 {
 	return resourceOwnerId_;
@@ -80,6 +91,17 @@ void DescribeVServerGroupsRequest::setRegionId(const std::string& regionId)
 	setParameter("RegionId", regionId);
 }
 
+bool DescribeVServerGroupsRequest::getIncludeListener()const
+{
+	return includeListener_;
+}
+
+void DescribeVServerGroupsRequest::setIncludeListener(bool includeListener)
+{
+	includeListener_ = includeListener;
+	setParameter("IncludeListener", std::to_string(includeListener));
+}
+
 std::string DescribeVServerGroupsRequest::getOwnerAccount()const
 {
 	return ownerAccount_;

slb/src/model/DescribeVServerGroupsResult.cc

@@ -40,21 +40,46 @@ void DescribeVServerGroupsResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allVServerGroups = value["VServerGroups"]["VServerGroup"];
-	for (auto value : allVServerGroups)
-	{
-		VServerGroup vServerGroupsObject;
-		if(!value["VServerGroupId"].isNull())
-			vServerGroupsObject.vServerGroupId = value["VServerGroupId"].asString();
-		if(!value["VServerGroupName"].isNull())
-			vServerGroupsObject.vServerGroupName = value["VServerGroupName"].asString();
-		vServerGroups_.push_back(vServerGroupsObject);
-	}
+	auto allVServerGroups = value["VServerGroups"]["VServerGroup"];
+	for (auto value : allVServerGroups)
+	{
+		VServerGroup vServerGroupsObject;
+		if(!value["VServerGroupId"].isNull())
+			vServerGroupsObject.vServerGroupId = value["VServerGroupId"].asString();
+		if(!value["VServerGroupName"].isNull())
+			vServerGroupsObject.vServerGroupName = value["VServerGroupName"].asString();
+		auto associatedObjectsNode = value["AssociatedObjects"];
+		auto allListeners = value["Listeners"]["Listener"];
+		for (auto value : allListeners)
+		{
+			VServerGroup::AssociatedObjects::Listener listenerObject;
+			if(!value["Protocol"].isNull())
+				listenerObject.protocol = value["Protocol"].asString();
+			if(!value["Port"].isNull())
+				listenerObject.port = std::stoi(value["Port"].asString());
+			vServerGroupsObject.associatedObjects.listeners.push_back(listenerObject);
+		}
+		auto allRules = value["Rules"]["Rule"];
+		for (auto value : allRules)
+		{
+			VServerGroup::AssociatedObjects::Rule ruleObject;
+			if(!value["RuleId"].isNull())
+				ruleObject.ruleId = value["RuleId"].asString();
+			if(!value["Domain"].isNull())
+				ruleObject.domain = value["Domain"].asString();
+			if(!value["Url"].isNull())
+				ruleObject.url = value["Url"].asString();
+			if(!value["RuleName"].isNull())
+				ruleObject.ruleName = value["RuleName"].asString();
+			vServerGroupsObject.associatedObjects.rules.push_back(ruleObject);
+		}
+		vServerGroups_.push_back(vServerGroupsObject);
+	}
 
 }
 
-std::vector<DescribeVServerGroupsResult::VServerGroup> DescribeVServerGroupsResult::getVServerGroups()const
-{
-	return vServerGroups_;
-}
-
+std::vector<DescribeVServerGroupsResult::VServerGroup> DescribeVServerGroupsResult::getVServerGroups()const
+{
+	return vServerGroups_;
+}
+

slb/src/model/DescribeZonesResult.cc

@@ -40,31 +40,31 @@ void DescribeZonesResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allZones = value["Zones"]["Zone"];
-	for (auto value : allZones)
-	{
-		Zone zonesObject;
-		if(!value["ZoneId"].isNull())
-			zonesObject.zoneId = value["ZoneId"].asString();
-		if(!value["LocalName"].isNull())
-			zonesObject.localName = value["LocalName"].asString();
-		auto allSlaveZones = value["SlaveZones"]["SlaveZone"];
-		for (auto value : allSlaveZones)
-		{
-			Zone::SlaveZone slaveZonesObject;
-			if(!value["ZoneId"].isNull())
-				slaveZonesObject.zoneId = value["ZoneId"].asString();
-			if(!value["LocalName"].isNull())
-				slaveZonesObject.localName = value["LocalName"].asString();
-			zonesObject.slaveZones.push_back(slaveZonesObject);
-		}
-		zones_.push_back(zonesObject);
-	}
+	auto allZones = value["Zones"]["Zone"];
+	for (auto value : allZones)
+	{
+		Zone zonesObject;
+		if(!value["ZoneId"].isNull())
+			zonesObject.zoneId = value["ZoneId"].asString();
+		if(!value["LocalName"].isNull())
+			zonesObject.localName = value["LocalName"].asString();
+		auto allSlaveZones = value["SlaveZones"]["SlaveZone"];
+		for (auto value : allSlaveZones)
+		{
+			Zone::SlaveZone slaveZonesObject;
+			if(!value["ZoneId"].isNull())
+				slaveZonesObject.zoneId = value["ZoneId"].asString();
+			if(!value["LocalName"].isNull())
+				slaveZonesObject.localName = value["LocalName"].asString();
+			zonesObject.slaveZones.push_back(slaveZonesObject);
+		}
+		zones_.push_back(zonesObject);
+	}
 
 }
 
-std::vector<DescribeZonesResult::Zone> DescribeZonesResult::getZones()const
-{
-	return zones_;
-}
-
+std::vector<DescribeZonesResult::Zone> DescribeZonesResult::getZones()const
+{
+	return zones_;
+}
+

slb/src/model/ModifyLoadBalancerInstanceSpecResult.cc

@@ -40,13 +40,13 @@ void ModifyLoadBalancerInstanceSpecResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["OrderId"].isNull())
-		orderId_ = std::stol(value["OrderId"].asString());
+	if(!value["OrderId"].isNull())
+		orderId_ = std::stol(value["OrderId"].asString());
 
 }
 
-long ModifyLoadBalancerInstanceSpecResult::getOrderId()const
-{
-	return orderId_;
-}
-
+long ModifyLoadBalancerInstanceSpecResult::getOrderId()const
+{
+	return orderId_;
+}
+

slb/src/model/ModifyLoadBalancerInternetSpecResult.cc

@@ -40,13 +40,13 @@ void ModifyLoadBalancerInternetSpecResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["OrderId"].isNull())
-		orderId_ = std::stol(value["OrderId"].asString());
+	if(!value["OrderId"].isNull())
+		orderId_ = std::stol(value["OrderId"].asString());
 
 }
 
-long ModifyLoadBalancerInternetSpecResult::getOrderId()const
-{
-	return orderId_;
-}
-
+long ModifyLoadBalancerInternetSpecResult::getOrderId()const
+{
+	return orderId_;
+}
+

slb/src/model/ModifyLoadBalancerPayTypeResult.cc

@@ -40,13 +40,13 @@ void ModifyLoadBalancerPayTypeResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["OrderId"].isNull())
-		orderId_ = std::stol(value["OrderId"].asString());
+	if(!value["OrderId"].isNull())
+		orderId_ = std::stol(value["OrderId"].asString());
 
 }
 
-long ModifyLoadBalancerPayTypeResult::getOrderId()const
-{
-	return orderId_;
-}
-
+long ModifyLoadBalancerPayTypeResult::getOrderId()const
+{
+	return orderId_;
+}
+

slb/src/model/ModifyVServerGroupBackendServersResult.cc

@@ -40,30 +40,38 @@ void ModifyVServerGroupBackendServersResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allBackendServers = value["BackendServers"]["BackendServer"];
-	for (auto value : allBackendServers)
-	{
-		BackendServer backendServersObject;
-		if(!value["ServerId"].isNull())
-			backendServersObject.serverId = value["ServerId"].asString();
-		if(!value["Port"].isNull())
-			backendServersObject.port = std::stoi(value["Port"].asString());
-		if(!value["Weight"].isNull())
-			backendServersObject.weight = std::stoi(value["Weight"].asString());
-		backendServers_.push_back(backendServersObject);
-	}
-	if(!value["VServerGroupId"].isNull())
-		vServerGroupId_ = value["VServerGroupId"].asString();
+	auto allBackendServers = value["BackendServers"]["BackendServer"];
+	for (auto value : allBackendServers)
+	{
+		BackendServer backendServersObject;
+		if(!value["ServerId"].isNull())
+			backendServersObject.serverId = value["ServerId"].asString();
+		if(!value["Port"].isNull())
+			backendServersObject.port = std::stoi(value["Port"].asString());
+		if(!value["Weight"].isNull())
+			backendServersObject.weight = std::stoi(value["Weight"].asString());
+		if(!value["Type"].isNull())
+			backendServersObject.type = value["Type"].asString();
+		if(!value["ServerIp"].isNull())
+			backendServersObject.serverIp = value["ServerIp"].asString();
+		if(!value["EniHost"].isNull())
+			backendServersObject.eniHost = value["EniHost"].asString();
+		if(!value["VpcId"].isNull())
+			backendServersObject.vpcId = value["VpcId"].asString();
+		backendServers_.push_back(backendServersObject);
+	}
+	if(!value["VServerGroupId"].isNull())
+		vServerGroupId_ = value["VServerGroupId"].asString();
 
 }
 
-std::string ModifyVServerGroupBackendServersResult::getVServerGroupId()const
-{
-	return vServerGroupId_;
-}
-
-std::vector<ModifyVServerGroupBackendServersResult::BackendServer> ModifyVServerGroupBackendServersResult::getBackendServers()const
-{
-	return backendServers_;
-}
-
+std::string ModifyVServerGroupBackendServersResult::getVServerGroupId()const
+{
+	return vServerGroupId_;
+}
+
+std::vector<ModifyVServerGroupBackendServersResult::BackendServer> ModifyVServerGroupBackendServersResult::getBackendServers()const
+{
+	return backendServers_;
+}
+

slb/src/model/RemoveAccessControlListEntryRequest.cc

@@ -0,0 +1,137 @@
+/*
+ * 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/slb/model/RemoveAccessControlListEntryRequest.h>
+
+using AlibabaCloud::Slb::Model::RemoveAccessControlListEntryRequest;
+
+RemoveAccessControlListEntryRequest::RemoveAccessControlListEntryRequest() :
+	RpcServiceRequest("slb", "2014-05-15", "RemoveAccessControlListEntry")
+{}
+
+RemoveAccessControlListEntryRequest::~RemoveAccessControlListEntryRequest()
+{}
+
+std::string RemoveAccessControlListEntryRequest::getAccess_key_id()const
+{
+	return access_key_id_;
+}
+
+void RemoveAccessControlListEntryRequest::setAccess_key_id(const std::string& access_key_id)
+{
+	access_key_id_ = access_key_id;
+	setParameter("Access_key_id", access_key_id);
+}
+
+std::string RemoveAccessControlListEntryRequest::getAclId()const
+{
+	return aclId_;
+}
+
+void RemoveAccessControlListEntryRequest::setAclId(const std::string& aclId)
+{
+	aclId_ = aclId;
+	setParameter("AclId", aclId);
+}
+
+long RemoveAccessControlListEntryRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void RemoveAccessControlListEntryRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string RemoveAccessControlListEntryRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void RemoveAccessControlListEntryRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string RemoveAccessControlListEntryRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void RemoveAccessControlListEntryRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string RemoveAccessControlListEntryRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void RemoveAccessControlListEntryRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string RemoveAccessControlListEntryRequest::getAclEntrys()const
+{
+	return aclEntrys_;
+}
+
+void RemoveAccessControlListEntryRequest::setAclEntrys(const std::string& aclEntrys)
+{
+	aclEntrys_ = aclEntrys;
+	setParameter("AclEntrys", aclEntrys);
+}
+
+long RemoveAccessControlListEntryRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void RemoveAccessControlListEntryRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string RemoveAccessControlListEntryRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void RemoveAccessControlListEntryRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string RemoveAccessControlListEntryRequest::getTags()const
+{
+	return tags_;
+}
+
+void RemoveAccessControlListEntryRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+

slb/src/model/RemoveAccessControlListEntryResult.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/slb/model/RemoveAccessControlListEntryResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+RemoveAccessControlListEntryResult::RemoveAccessControlListEntryResult() :
+	ServiceResult()
+{}
+
+RemoveAccessControlListEntryResult::RemoveAccessControlListEntryResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+RemoveAccessControlListEntryResult::~RemoveAccessControlListEntryResult()
+{}
+
+void RemoveAccessControlListEntryResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+
+}
+

slb/src/model/RemoveBackendServersResult.cc

@@ -40,28 +40,34 @@ void RemoveBackendServersResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allBackendServers = value["BackendServers"]["BackendServer"];
-	for (auto value : allBackendServers)
-	{
-		BackendServer backendServersObject;
-		if(!value["ServerId"].isNull())
-			backendServersObject.serverId = value["ServerId"].asString();
-		if(!value["Weight"].isNull())
-			backendServersObject.weight = std::stoi(value["Weight"].asString());
-		backendServers_.push_back(backendServersObject);
-	}
-	if(!value["LoadBalancerId"].isNull())
-		loadBalancerId_ = value["LoadBalancerId"].asString();
+	auto allBackendServers = value["BackendServers"]["BackendServer"];
+	for (auto value : allBackendServers)
+	{
+		BackendServer backendServersObject;
+		if(!value["ServerId"].isNull())
+			backendServersObject.serverId = value["ServerId"].asString();
+		if(!value["Weight"].isNull())
+			backendServersObject.weight = std::stoi(value["Weight"].asString());
+		if(!value["ServerIp"].isNull())
+			backendServersObject.serverIp = value["ServerIp"].asString();
+		if(!value["VpcId"].isNull())
+			backendServersObject.vpcId = value["VpcId"].asString();
+		if(!value["Type"].isNull())
+			backendServersObject.type = value["Type"].asString();
+		backendServers_.push_back(backendServersObject);
+	}
+	if(!value["LoadBalancerId"].isNull())
+		loadBalancerId_ = value["LoadBalancerId"].asString();
 
 }
 
-std::string RemoveBackendServersResult::getLoadBalancerId()const
-{
-	return loadBalancerId_;
-}
-
-std::vector<RemoveBackendServersResult::BackendServer> RemoveBackendServersResult::getBackendServers()const
-{
-	return backendServers_;
-}
-
+std::string RemoveBackendServersResult::getLoadBalancerId()const
+{
+	return loadBalancerId_;
+}
+
+std::vector<RemoveBackendServersResult::BackendServer> RemoveBackendServersResult::getBackendServers()const
+{
+	return backendServers_;
+}
+

slb/src/model/RemoveVServerGroupBackendServersResult.cc

@@ -40,30 +40,38 @@ void RemoveVServerGroupBackendServersResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allBackendServers = value["BackendServers"]["BackendServer"];
-	for (auto value : allBackendServers)
-	{
-		BackendServer backendServersObject;
-		if(!value["ServerId"].isNull())
-			backendServersObject.serverId = value["ServerId"].asString();
-		if(!value["Port"].isNull())
-			backendServersObject.port = std::stoi(value["Port"].asString());
-		if(!value["Weight"].isNull())
-			backendServersObject.weight = std::stoi(value["Weight"].asString());
-		backendServers_.push_back(backendServersObject);
-	}
-	if(!value["VServerGroupId"].isNull())
-		vServerGroupId_ = value["VServerGroupId"].asString();
+	auto allBackendServers = value["BackendServers"]["BackendServer"];
+	for (auto value : allBackendServers)
+	{
+		BackendServer backendServersObject;
+		if(!value["ServerId"].isNull())
+			backendServersObject.serverId = value["ServerId"].asString();
+		if(!value["Port"].isNull())
+			backendServersObject.port = std::stoi(value["Port"].asString());
+		if(!value["Weight"].isNull())
+			backendServersObject.weight = std::stoi(value["Weight"].asString());
+		if(!value["Type"].isNull())
+			backendServersObject.type = value["Type"].asString();
+		if(!value["ServerIp"].isNull())
+			backendServersObject.serverIp = value["ServerIp"].asString();
+		if(!value["EniHost"].isNull())
+			backendServersObject.eniHost = value["EniHost"].asString();
+		if(!value["VpcId"].isNull())
+			backendServersObject.vpcId = value["VpcId"].asString();
+		backendServers_.push_back(backendServersObject);
+	}
+	if(!value["VServerGroupId"].isNull())
+		vServerGroupId_ = value["VServerGroupId"].asString();
 
 }
 
-std::string RemoveVServerGroupBackendServersResult::getVServerGroupId()const
-{
-	return vServerGroupId_;
-}
-
-std::vector<RemoveVServerGroupBackendServersResult::BackendServer> RemoveVServerGroupBackendServersResult::getBackendServers()const
-{
-	return backendServers_;
-}
-
+std::string RemoveVServerGroupBackendServersResult::getVServerGroupId()const
+{
+	return vServerGroupId_;
+}
+
+std::vector<RemoveVServerGroupBackendServersResult::BackendServer> RemoveVServerGroupBackendServersResult::getBackendServers()const
+{
+	return backendServers_;
+}
+

slb/src/model/SetAccessControlListAttributeRequest.cc

@@ -0,0 +1,137 @@
+/*
+ * 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/slb/model/SetAccessControlListAttributeRequest.h>
+
+using AlibabaCloud::Slb::Model::SetAccessControlListAttributeRequest;
+
+SetAccessControlListAttributeRequest::SetAccessControlListAttributeRequest() :
+	RpcServiceRequest("slb", "2014-05-15", "SetAccessControlListAttribute")
+{}
+
+SetAccessControlListAttributeRequest::~SetAccessControlListAttributeRequest()
+{}
+
+std::string SetAccessControlListAttributeRequest::getAccess_key_id()const
+{
+	return access_key_id_;
+}
+
+void SetAccessControlListAttributeRequest::setAccess_key_id(const std::string& access_key_id)
+{
+	access_key_id_ = access_key_id;
+	setParameter("Access_key_id", access_key_id);
+}
+
+std::string SetAccessControlListAttributeRequest::getAclId()const
+{
+	return aclId_;
+}
+
+void SetAccessControlListAttributeRequest::setAclId(const std::string& aclId)
+{
+	aclId_ = aclId;
+	setParameter("AclId", aclId);
+}
+
+long SetAccessControlListAttributeRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void SetAccessControlListAttributeRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string SetAccessControlListAttributeRequest::getAclName()const
+{
+	return aclName_;
+}
+
+void SetAccessControlListAttributeRequest::setAclName(const std::string& aclName)
+{
+	aclName_ = aclName;
+	setParameter("AclName", aclName);
+}
+
+std::string SetAccessControlListAttributeRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void SetAccessControlListAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string SetAccessControlListAttributeRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void SetAccessControlListAttributeRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string SetAccessControlListAttributeRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void SetAccessControlListAttributeRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long SetAccessControlListAttributeRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void SetAccessControlListAttributeRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string SetAccessControlListAttributeRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void SetAccessControlListAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string SetAccessControlListAttributeRequest::getTags()const
+{
+	return tags_;
+}
+
+void SetAccessControlListAttributeRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+

slb/src/model/SetAccessControlListAttributeResult.cc

@@ -0,0 +1,52 @@
+/*
+ * 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/slb/model/SetAccessControlListAttributeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+SetAccessControlListAttributeResult::SetAccessControlListAttributeResult() :
+	ServiceResult()
+{}
+
+SetAccessControlListAttributeResult::SetAccessControlListAttributeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SetAccessControlListAttributeResult::~SetAccessControlListAttributeResult()
+{}
+
+void SetAccessControlListAttributeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	if(!value["AclId"].isNull())
+		aclId_ = value["AclId"].asString();
+
+}
+
+std::string SetAccessControlListAttributeResult::getAclId()const
+{
+	return aclId_;
+}
+

slb/src/model/SetAutoRenewStatusRequest.cc

@@ -0,0 +1,148 @@
+/*
+ * 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/slb/model/SetAutoRenewStatusRequest.h>
+
+using AlibabaCloud::Slb::Model::SetAutoRenewStatusRequest;
+
+SetAutoRenewStatusRequest::SetAutoRenewStatusRequest() :
+	RpcServiceRequest("slb", "2014-05-15", "SetAutoRenewStatus")
+{}
+
+SetAutoRenewStatusRequest::~SetAutoRenewStatusRequest()
+{}
+
+std::string SetAutoRenewStatusRequest::getAccess_key_id()const
+{
+	return access_key_id_;
+}
+
+void SetAutoRenewStatusRequest::setAccess_key_id(const std::string& access_key_id)
+{
+	access_key_id_ = access_key_id;
+	setParameter("Access_key_id", access_key_id);
+}
+
+long SetAutoRenewStatusRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void SetAutoRenewStatusRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+int SetAutoRenewStatusRequest::getRenewalDuration()const
+{
+	return renewalDuration_;
+}
+
+void SetAutoRenewStatusRequest::setRenewalDuration(int renewalDuration)
+{
+	renewalDuration_ = renewalDuration;
+	setParameter("RenewalDuration", std::to_string(renewalDuration));
+}
+
+std::string SetAutoRenewStatusRequest::getLoadBalancerId()const
+{
+	return loadBalancerId_;
+}
+
+void SetAutoRenewStatusRequest::setLoadBalancerId(const std::string& loadBalancerId)
+{
+	loadBalancerId_ = loadBalancerId;
+	setParameter("LoadBalancerId", loadBalancerId);
+}
+
+std::string SetAutoRenewStatusRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void SetAutoRenewStatusRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string SetAutoRenewStatusRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void SetAutoRenewStatusRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string SetAutoRenewStatusRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void SetAutoRenewStatusRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string SetAutoRenewStatusRequest::getRenewalStatus()const
+{
+	return renewalStatus_;
+}
+
+void SetAutoRenewStatusRequest::setRenewalStatus(const std::string& renewalStatus)
+{
+	renewalStatus_ = renewalStatus;
+	setParameter("RenewalStatus", renewalStatus);
+}
+
+std::string SetAutoRenewStatusRequest::getRenewalCycUnit()const
+{
+	return renewalCycUnit_;
+}
+
+void SetAutoRenewStatusRequest::setRenewalCycUnit(const std::string& renewalCycUnit)
+{
+	renewalCycUnit_ = renewalCycUnit;
+	setParameter("RenewalCycUnit", renewalCycUnit);
+}
+
+long SetAutoRenewStatusRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void SetAutoRenewStatusRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string SetAutoRenewStatusRequest::getTags()const
+{
+	return tags_;
+}
+
+void SetAutoRenewStatusRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+

slb/src/model/SetAutoRenewStatusResult.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/slb/model/SetAutoRenewStatusResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+SetAutoRenewStatusResult::SetAutoRenewStatusResult() :
+	ServiceResult()
+{}
+
+SetAutoRenewStatusResult::SetAutoRenewStatusResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SetAutoRenewStatusResult::~SetAutoRenewStatusResult()
+{}
+
+void SetAutoRenewStatusResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+
+}
+

slb/src/model/SetBackendServersResult.cc

@@ -40,28 +40,36 @@ void SetBackendServersResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allBackendServers = value["BackendServers"]["BackendServer"];
-	for (auto value : allBackendServers)
-	{
-		BackendServer backendServersObject;
-		if(!value["ServerId"].isNull())
-			backendServersObject.serverId = value["ServerId"].asString();
-		if(!value["Weight"].isNull())
-			backendServersObject.weight = value["Weight"].asString();
-		backendServers_.push_back(backendServersObject);
-	}
-	if(!value["LoadBalancerId"].isNull())
-		loadBalancerId_ = value["LoadBalancerId"].asString();
+	auto allBackendServers = value["BackendServers"]["BackendServer"];
+	for (auto value : allBackendServers)
+	{
+		BackendServer backendServersObject;
+		if(!value["ServerId"].isNull())
+			backendServersObject.serverId = value["ServerId"].asString();
+		if(!value["Weight"].isNull())
+			backendServersObject.weight = value["Weight"].asString();
+		if(!value["ServerIp"].isNull())
+			backendServersObject.serverIp = value["ServerIp"].asString();
+		if(!value["VpcId"].isNull())
+			backendServersObject.vpcId = value["VpcId"].asString();
+		if(!value["EniHost"].isNull())
+			backendServersObject.eniHost = value["EniHost"].asString();
+		if(!value["Type"].isNull())
+			backendServersObject.type = value["Type"].asString();
+		backendServers_.push_back(backendServersObject);
+	}
+	if(!value["LoadBalancerId"].isNull())
+		loadBalancerId_ = value["LoadBalancerId"].asString();
 
 }
 
-std::string SetBackendServersResult::getLoadBalancerId()const
-{
-	return loadBalancerId_;
-}
-
-std::vector<SetBackendServersResult::BackendServer> SetBackendServersResult::getBackendServers()const
-{
-	return backendServers_;
-}
-
+std::string SetBackendServersResult::getLoadBalancerId()const
+{
+	return loadBalancerId_;
+}
+
+std::vector<SetBackendServersResult::BackendServer> SetBackendServersResult::getBackendServers()const
+{
+	return backendServers_;
+}
+

slb/src/model/SetDomainExtensionAttributeRequest.cc

@@ -0,0 +1,126 @@
+/*
+ * 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/slb/model/SetDomainExtensionAttributeRequest.h>
+
+using AlibabaCloud::Slb::Model::SetDomainExtensionAttributeRequest;
+
+SetDomainExtensionAttributeRequest::SetDomainExtensionAttributeRequest() :
+	RpcServiceRequest("slb", "2014-05-15", "SetDomainExtensionAttribute")
+{}
+
+SetDomainExtensionAttributeRequest::~SetDomainExtensionAttributeRequest()
+{}
+
+std::string SetDomainExtensionAttributeRequest::getAccess_key_id()const
+{
+	return access_key_id_;
+}
+
+void SetDomainExtensionAttributeRequest::setAccess_key_id(const std::string& access_key_id)
+{
+	access_key_id_ = access_key_id;
+	setParameter("Access_key_id", access_key_id);
+}
+
+long SetDomainExtensionAttributeRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void SetDomainExtensionAttributeRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string SetDomainExtensionAttributeRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void SetDomainExtensionAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string SetDomainExtensionAttributeRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void SetDomainExtensionAttributeRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string SetDomainExtensionAttributeRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void SetDomainExtensionAttributeRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long SetDomainExtensionAttributeRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void SetDomainExtensionAttributeRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string SetDomainExtensionAttributeRequest::getServerCertificateId()const
+{
+	return serverCertificateId_;
+}
+
+void SetDomainExtensionAttributeRequest::setServerCertificateId(const std::string& serverCertificateId)
+{
+	serverCertificateId_ = serverCertificateId;
+	setParameter("ServerCertificateId", serverCertificateId);
+}
+
+std::string SetDomainExtensionAttributeRequest::getTags()const
+{
+	return tags_;
+}
+
+void SetDomainExtensionAttributeRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+
+std::string SetDomainExtensionAttributeRequest::getDomainExtensionId()const
+{
+	return domainExtensionId_;
+}
+
+void SetDomainExtensionAttributeRequest::setDomainExtensionId(const std::string& domainExtensionId)
+{
+	domainExtensionId_ = domainExtensionId;
+	setParameter("DomainExtensionId", domainExtensionId);
+}
+

slb/src/model/SetDomainExtensionAttributeResult.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/slb/model/SetDomainExtensionAttributeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+SetDomainExtensionAttributeResult::SetDomainExtensionAttributeResult() :
+	ServiceResult()
+{}
+
+SetDomainExtensionAttributeResult::SetDomainExtensionAttributeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SetDomainExtensionAttributeResult::~SetDomainExtensionAttributeResult()
+{}
+
+void SetDomainExtensionAttributeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+
+}
+

slb/src/model/SetLoadBalancerHTTPListenerAttributeRequest.cc

@@ -80,6 +80,17 @@ void SetLoadBalancerHTTPListenerAttributeRequest::setHealthCheckURI(const std::s
 	setParameter("HealthCheckURI", healthCheckURI);
 }
 
+std::string SetLoadBalancerHTTPListenerAttributeRequest::getDescription()const
+{
+	return description_;
+}
+
+void SetLoadBalancerHTTPListenerAttributeRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
 int SetLoadBalancerHTTPListenerAttributeRequest::getUnhealthyThreshold()const
 {
 	return unhealthyThreshold_;
@@ -102,6 +113,17 @@ void SetLoadBalancerHTTPListenerAttributeRequest::setHealthyThreshold(int health
 	setParameter("HealthyThreshold", std::to_string(healthyThreshold));
 }
 
+std::string SetLoadBalancerHTTPListenerAttributeRequest::getAclStatus()const
+{
+	return aclStatus_;
+}
+
+void SetLoadBalancerHTTPListenerAttributeRequest::setAclStatus(const std::string& aclStatus)
+{
+	aclStatus_ = aclStatus;
+	setParameter("AclStatus", aclStatus);
+}
+
 std::string SetLoadBalancerHTTPListenerAttributeRequest::getScheduler()const
 {
 	return scheduler_;
@@ -113,6 +135,17 @@ void SetLoadBalancerHTTPListenerAttributeRequest::setScheduler(const std::string
 	setParameter("Scheduler", scheduler);
 }
 
+std::string SetLoadBalancerHTTPListenerAttributeRequest::getAclType()const
+{
+	return aclType_;
+}
+
+void SetLoadBalancerHTTPListenerAttributeRequest::setAclType(const std::string& aclType)
+{
+	aclType_ = aclType;
+	setParameter("AclType", aclType);
+}
+
 std::string SetLoadBalancerHTTPListenerAttributeRequest::getHealthCheck()const
 {
 	return healthCheck_;
@@ -168,6 +201,17 @@ void SetLoadBalancerHTTPListenerAttributeRequest::setStickySessionType(const std
 	setParameter("StickySessionType", stickySessionType);
 }
 
+std::string SetLoadBalancerHTTPListenerAttributeRequest::getVpcIds()const
+{
+	return vpcIds_;
+}
+
+void SetLoadBalancerHTTPListenerAttributeRequest::setVpcIds(const std::string& vpcIds)
+{
+	vpcIds_ = vpcIds;
+	setParameter("VpcIds", vpcIds);
+}
+
 std::string SetLoadBalancerHTTPListenerAttributeRequest::getVServerGroupId()const
 {
 	return vServerGroupId_;
@@ -179,6 +223,17 @@ void SetLoadBalancerHTTPListenerAttributeRequest::setVServerGroupId(const std::s
 	setParameter("VServerGroupId", vServerGroupId);
 }
 
+std::string SetLoadBalancerHTTPListenerAttributeRequest::getAclId()const
+{
+	return aclId_;
+}
+
+void SetLoadBalancerHTTPListenerAttributeRequest::setAclId(const std::string& aclId)
+{
+	aclId_ = aclId;
+	setParameter("AclId", aclId);
+}
+
 int SetLoadBalancerHTTPListenerAttributeRequest::getListenerPort()const
 {
 	return listenerPort_;
@@ -245,6 +300,17 @@ void SetLoadBalancerHTTPListenerAttributeRequest::setHealthCheckDomain(const std
 	setParameter("HealthCheckDomain", healthCheckDomain);
 }
 
+int SetLoadBalancerHTTPListenerAttributeRequest::getRequestTimeout()const
+{
+	return requestTimeout_;
+}
+
+void SetLoadBalancerHTTPListenerAttributeRequest::setRequestTimeout(int requestTimeout)
+{
+	requestTimeout_ = requestTimeout;
+	setParameter("RequestTimeout", std::to_string(requestTimeout));
+}
+
 std::string SetLoadBalancerHTTPListenerAttributeRequest::getOwnerAccount()const
 {
 	return ownerAccount_;
@@ -289,6 +355,17 @@ void SetLoadBalancerHTTPListenerAttributeRequest::setTags(const std::string& tag
 	setParameter("Tags", tags);
 }
 
+int SetLoadBalancerHTTPListenerAttributeRequest::getIdleTimeout()const
+{
+	return idleTimeout_;
+}
+
+void SetLoadBalancerHTTPListenerAttributeRequest::setIdleTimeout(int idleTimeout)
+{
+	idleTimeout_ = idleTimeout;
+	setParameter("IdleTimeout", std::to_string(idleTimeout));
+}
+
 std::string SetLoadBalancerHTTPListenerAttributeRequest::getLoadBalancerId()const
 {
 	return loadBalancerId_;

slb/src/model/SetLoadBalancerHTTPSListenerAttributeRequest.cc

@@ -80,6 +80,17 @@ void SetLoadBalancerHTTPSListenerAttributeRequest::setHealthCheckURI(const std::
 	setParameter("HealthCheckURI", healthCheckURI);
 }
 
+std::string SetLoadBalancerHTTPSListenerAttributeRequest::getDescription()const
+{
+	return description_;
+}
+
+void SetLoadBalancerHTTPSListenerAttributeRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
 int SetLoadBalancerHTTPSListenerAttributeRequest::getUnhealthyThreshold()const
 {
 	return unhealthyThreshold_;
@@ -102,6 +113,17 @@ void SetLoadBalancerHTTPSListenerAttributeRequest::setHealthyThreshold(int healt
 	setParameter("HealthyThreshold", std::to_string(healthyThreshold));
 }
 
+std::string SetLoadBalancerHTTPSListenerAttributeRequest::getAclStatus()const
+{
+	return aclStatus_;
+}
+
+void SetLoadBalancerHTTPSListenerAttributeRequest::setAclStatus(const std::string& aclStatus)
+{
+	aclStatus_ = aclStatus;
+	setParameter("AclStatus", aclStatus);
+}
+
 std::string SetLoadBalancerHTTPSListenerAttributeRequest::getScheduler()const
 {
 	return scheduler_;
@@ -113,6 +135,17 @@ void SetLoadBalancerHTTPSListenerAttributeRequest::setScheduler(const std::strin
 	setParameter("Scheduler", scheduler);
 }
 
+std::string SetLoadBalancerHTTPSListenerAttributeRequest::getAclType()const
+{
+	return aclType_;
+}
+
+void SetLoadBalancerHTTPSListenerAttributeRequest::setAclType(const std::string& aclType)
+{
+	aclType_ = aclType;
+	setParameter("AclType", aclType);
+}
+
 std::string SetLoadBalancerHTTPSListenerAttributeRequest::getHealthCheck()const
 {
 	return healthCheck_;
@@ -135,6 +168,17 @@ void SetLoadBalancerHTTPSListenerAttributeRequest::setMaxConnection(int maxConne
 	setParameter("MaxConnection", std::to_string(maxConnection));
 }
 
+std::string SetLoadBalancerHTTPSListenerAttributeRequest::getEnableHttp2()const
+{
+	return enableHttp2_;
+}
+
+void SetLoadBalancerHTTPSListenerAttributeRequest::setEnableHttp2(const std::string& enableHttp2)
+{
+	enableHttp2_ = enableHttp2;
+	setParameter("EnableHttp2", enableHttp2);
+}
+
 std::string SetLoadBalancerHTTPSListenerAttributeRequest::getRegionId()const
 {
 	return regionId_;
@@ -168,6 +212,17 @@ void SetLoadBalancerHTTPSListenerAttributeRequest::setStickySessionType(const st
 	setParameter("StickySessionType", stickySessionType);
 }
 
+std::string SetLoadBalancerHTTPSListenerAttributeRequest::getVpcIds()const
+{
+	return vpcIds_;
+}
+
+void SetLoadBalancerHTTPSListenerAttributeRequest::setVpcIds(const std::string& vpcIds)
+{
+	vpcIds_ = vpcIds;
+	setParameter("VpcIds", vpcIds);
+}
+
 std::string SetLoadBalancerHTTPSListenerAttributeRequest::getVServerGroupId()const
 {
 	return vServerGroupId_;
@@ -179,6 +234,17 @@ void SetLoadBalancerHTTPSListenerAttributeRequest::setVServerGroupId(const std::
 	setParameter("VServerGroupId", vServerGroupId);
 }
 
+std::string SetLoadBalancerHTTPSListenerAttributeRequest::getAclId()const
+{
+	return aclId_;
+}
+
+void SetLoadBalancerHTTPSListenerAttributeRequest::setAclId(const std::string& aclId)
+{
+	aclId_ = aclId;
+	setParameter("AclId", aclId);
+}
+
 int SetLoadBalancerHTTPSListenerAttributeRequest::getListenerPort()const
 {
 	return listenerPort_;
@@ -245,6 +311,17 @@ void SetLoadBalancerHTTPSListenerAttributeRequest::setHealthCheckDomain(const st
 	setParameter("HealthCheckDomain", healthCheckDomain);
 }
 
+int SetLoadBalancerHTTPSListenerAttributeRequest::getRequestTimeout()const
+{
+	return requestTimeout_;
+}
+
+void SetLoadBalancerHTTPSListenerAttributeRequest::setRequestTimeout(int requestTimeout)
+{
+	requestTimeout_ = requestTimeout;
+	setParameter("RequestTimeout", std::to_string(requestTimeout));
+}
+
 std::string SetLoadBalancerHTTPSListenerAttributeRequest::getOwnerAccount()const
 {
 	return ownerAccount_;
@@ -267,6 +344,17 @@ void SetLoadBalancerHTTPSListenerAttributeRequest::setGzip(const std::string& gz
 	setParameter("Gzip", gzip);
 }
 
+std::string SetLoadBalancerHTTPSListenerAttributeRequest::getTLSCipherPolicy()const
+{
+	return tLSCipherPolicy_;
+}
+
+void SetLoadBalancerHTTPSListenerAttributeRequest::setTLSCipherPolicy(const std::string& tLSCipherPolicy)
+{
+	tLSCipherPolicy_ = tLSCipherPolicy;
+	setParameter("TLSCipherPolicy", tLSCipherPolicy);
+}
+
 long SetLoadBalancerHTTPSListenerAttributeRequest::getOwnerId()const
 {
 	return ownerId_;
@@ -311,6 +399,17 @@ void SetLoadBalancerHTTPSListenerAttributeRequest::setTags(const std::string& ta
 	setParameter("Tags", tags);
 }
 
+int SetLoadBalancerHTTPSListenerAttributeRequest::getIdleTimeout()const
+{
+	return idleTimeout_;
+}
+
+void SetLoadBalancerHTTPSListenerAttributeRequest::setIdleTimeout(int idleTimeout)
+{
+	idleTimeout_ = idleTimeout;
+	setParameter("IdleTimeout", std::to_string(idleTimeout));
+}
+
 std::string SetLoadBalancerHTTPSListenerAttributeRequest::getLoadBalancerId()const
 {
 	return loadBalancerId_;

slb/src/model/SetLoadBalancerTCPListenerAttributeRequest.cc

@@ -69,6 +69,17 @@ void SetLoadBalancerTCPListenerAttributeRequest::setHealthCheckURI(const std::st
 	setParameter("HealthCheckURI", healthCheckURI);
 }
 
+std::string SetLoadBalancerTCPListenerAttributeRequest::getDescription()const
+{
+	return description_;
+}
+
+void SetLoadBalancerTCPListenerAttributeRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
 int SetLoadBalancerTCPListenerAttributeRequest::getUnhealthyThreshold()const
 {
 	return unhealthyThreshold_;
@@ -91,6 +102,17 @@ void SetLoadBalancerTCPListenerAttributeRequest::setHealthyThreshold(int healthy
 	setParameter("HealthyThreshold", std::to_string(healthyThreshold));
 }
 
+std::string SetLoadBalancerTCPListenerAttributeRequest::getAclStatus()const
+{
+	return aclStatus_;
+}
+
+void SetLoadBalancerTCPListenerAttributeRequest::setAclStatus(const std::string& aclStatus)
+{
+	aclStatus_ = aclStatus;
+	setParameter("AclStatus", aclStatus);
+}
+
 std::string SetLoadBalancerTCPListenerAttributeRequest::getScheduler()const
 {
 	return scheduler_;
@@ -102,6 +124,17 @@ void SetLoadBalancerTCPListenerAttributeRequest::setScheduler(const std::string&
 	setParameter("Scheduler", scheduler);
 }
 
+std::string SetLoadBalancerTCPListenerAttributeRequest::getAclType()const
+{
+	return aclType_;
+}
+
+void SetLoadBalancerTCPListenerAttributeRequest::setAclType(const std::string& aclType)
+{
+	aclType_ = aclType;
+	setParameter("AclType", aclType);
+}
+
 std::string SetLoadBalancerTCPListenerAttributeRequest::getMasterSlaveServerGroup()const
 {
 	return masterSlaveServerGroup_;
@@ -157,6 +190,17 @@ void SetLoadBalancerTCPListenerAttributeRequest::setPersistenceTimeout(int persi
 	setParameter("PersistenceTimeout", std::to_string(persistenceTimeout));
 }
 
+std::string SetLoadBalancerTCPListenerAttributeRequest::getVpcIds()const
+{
+	return vpcIds_;
+}
+
+void SetLoadBalancerTCPListenerAttributeRequest::setVpcIds(const std::string& vpcIds)
+{
+	vpcIds_ = vpcIds;
+	setParameter("VpcIds", vpcIds);
+}
+
 std::string SetLoadBalancerTCPListenerAttributeRequest::getVServerGroupId()const
 {
 	return vServerGroupId_;
@@ -168,6 +212,17 @@ void SetLoadBalancerTCPListenerAttributeRequest::setVServerGroupId(const std::st
 	setParameter("VServerGroupId", vServerGroupId);
 }
 
+std::string SetLoadBalancerTCPListenerAttributeRequest::getAclId()const
+{
+	return aclId_;
+}
+
+void SetLoadBalancerTCPListenerAttributeRequest::setAclId(const std::string& aclId)
+{
+	aclId_ = aclId;
+	setParameter("AclId", aclId);
+}
+
 int SetLoadBalancerTCPListenerAttributeRequest::getListenerPort()const
 {
 	return listenerPort_;

slb/src/model/SetLoadBalancerUDPListenerAttributeRequest.cc

@@ -58,6 +58,17 @@ void SetLoadBalancerUDPListenerAttributeRequest::setResourceOwnerId(long resourc
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+std::string SetLoadBalancerUDPListenerAttributeRequest::getDescription()const
+{
+	return description_;
+}
+
+void SetLoadBalancerUDPListenerAttributeRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
 int SetLoadBalancerUDPListenerAttributeRequest::getUnhealthyThreshold()const
 {
 	return unhealthyThreshold_;
@@ -80,6 +91,17 @@ void SetLoadBalancerUDPListenerAttributeRequest::setHealthyThreshold(int healthy
 	setParameter("HealthyThreshold", std::to_string(healthyThreshold));
 }
 
+std::string SetLoadBalancerUDPListenerAttributeRequest::getAclStatus()const
+{
+	return aclStatus_;
+}
+
+void SetLoadBalancerUDPListenerAttributeRequest::setAclStatus(const std::string& aclStatus)
+{
+	aclStatus_ = aclStatus;
+	setParameter("AclStatus", aclStatus);
+}
+
 std::string SetLoadBalancerUDPListenerAttributeRequest::getScheduler()const
 {
 	return scheduler_;
@@ -91,6 +113,17 @@ void SetLoadBalancerUDPListenerAttributeRequest::setScheduler(const std::string&
 	setParameter("Scheduler", scheduler);
 }
 
+std::string SetLoadBalancerUDPListenerAttributeRequest::getAclType()const
+{
+	return aclType_;
+}
+
+void SetLoadBalancerUDPListenerAttributeRequest::setAclType(const std::string& aclType)
+{
+	aclType_ = aclType;
+	setParameter("AclType", aclType);
+}
+
 std::string SetLoadBalancerUDPListenerAttributeRequest::getMasterSlaveServerGroup()const
 {
 	return masterSlaveServerGroup_;
@@ -135,6 +168,17 @@ void SetLoadBalancerUDPListenerAttributeRequest::setPersistenceTimeout(int persi
 	setParameter("PersistenceTimeout", std::to_string(persistenceTimeout));
 }
 
+std::string SetLoadBalancerUDPListenerAttributeRequest::getVpcIds()const
+{
+	return vpcIds_;
+}
+
+void SetLoadBalancerUDPListenerAttributeRequest::setVpcIds(const std::string& vpcIds)
+{
+	vpcIds_ = vpcIds;
+	setParameter("VpcIds", vpcIds);
+}
+
 std::string SetLoadBalancerUDPListenerAttributeRequest::getVServerGroupId()const
 {
 	return vServerGroupId_;
@@ -146,6 +190,17 @@ void SetLoadBalancerUDPListenerAttributeRequest::setVServerGroupId(const std::st
 	setParameter("VServerGroupId", vServerGroupId);
 }
 
+std::string SetLoadBalancerUDPListenerAttributeRequest::getAclId()const
+{
+	return aclId_;
+}
+
+void SetLoadBalancerUDPListenerAttributeRequest::setAclId(const std::string& aclId)
+{
+	aclId_ = aclId;
+	setParameter("AclId", aclId);
+}
+
 int SetLoadBalancerUDPListenerAttributeRequest::getListenerPort()const
 {
 	return listenerPort_;

slb/src/model/SetRuleRequest.cc

@@ -36,6 +36,138 @@ void SetRuleRequest::setAccess_key_id(const std::string& access_key_id)
 	setParameter("Access_key_id", access_key_id);
 }
 
+long SetRuleRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void SetRuleRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+int SetRuleRequest::getHealthCheckTimeout()const
+{
+	return healthCheckTimeout_;
+}
+
+void SetRuleRequest::setHealthCheckTimeout(int healthCheckTimeout)
+{
+	healthCheckTimeout_ = healthCheckTimeout;
+	setParameter("HealthCheckTimeout", std::to_string(healthCheckTimeout));
+}
+
+std::string SetRuleRequest::getHealthCheckURI()const
+{
+	return healthCheckURI_;
+}
+
+void SetRuleRequest::setHealthCheckURI(const std::string& healthCheckURI)
+{
+	healthCheckURI_ = healthCheckURI;
+	setParameter("HealthCheckURI", healthCheckURI);
+}
+
+std::string SetRuleRequest::getRuleName()const
+{
+	return ruleName_;
+}
+
+void SetRuleRequest::setRuleName(const std::string& ruleName)
+{
+	ruleName_ = ruleName;
+	setParameter("RuleName", ruleName);
+}
+
+int SetRuleRequest::getUnhealthyThreshold()const
+{
+	return unhealthyThreshold_;
+}
+
+void SetRuleRequest::setUnhealthyThreshold(int unhealthyThreshold)
+{
+	unhealthyThreshold_ = unhealthyThreshold;
+	setParameter("UnhealthyThreshold", std::to_string(unhealthyThreshold));
+}
+
+int SetRuleRequest::getHealthyThreshold()const
+{
+	return healthyThreshold_;
+}
+
+void SetRuleRequest::setHealthyThreshold(int healthyThreshold)
+{
+	healthyThreshold_ = healthyThreshold;
+	setParameter("HealthyThreshold", std::to_string(healthyThreshold));
+}
+
+std::string SetRuleRequest::getScheduler()const
+{
+	return scheduler_;
+}
+
+void SetRuleRequest::setScheduler(const std::string& scheduler)
+{
+	scheduler_ = scheduler;
+	setParameter("Scheduler", scheduler);
+}
+
+std::string SetRuleRequest::getHealthCheck()const
+{
+	return healthCheck_;
+}
+
+void SetRuleRequest::setHealthCheck(const std::string& healthCheck)
+{
+	healthCheck_ = healthCheck;
+	setParameter("HealthCheck", healthCheck);
+}
+
+std::string SetRuleRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void SetRuleRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string SetRuleRequest::getListenerSync()const
+{
+	return listenerSync_;
+}
+
+void SetRuleRequest::setListenerSync(const std::string& listenerSync)
+{
+	listenerSync_ = listenerSync;
+	setParameter("ListenerSync", listenerSync);
+}
+
+int SetRuleRequest::getCookieTimeout()const
+{
+	return cookieTimeout_;
+}
+
+void SetRuleRequest::setCookieTimeout(int cookieTimeout)
+{
+	cookieTimeout_ = cookieTimeout;
+	setParameter("CookieTimeout", std::to_string(cookieTimeout));
+}
+
+std::string SetRuleRequest::getStickySessionType()const
+{
+	return stickySessionType_;
+}
+
+void SetRuleRequest::setStickySessionType(const std::string& stickySessionType)
+{
+	stickySessionType_ = stickySessionType;
+	setParameter("StickySessionType", stickySessionType);
+}
+
 std::string SetRuleRequest::getVServerGroupId()const
 {
 	return vServerGroupId_;
@@ -47,15 +179,15 @@ void SetRuleRequest::setVServerGroupId(const std::string& vServerGroupId)
 	setParameter("VServerGroupId", vServerGroupId);
 }
 
-long SetRuleRequest::getResourceOwnerId()const
+std::string SetRuleRequest::getCookie()const
 {
-	return resourceOwnerId_;
+	return cookie_;
 }
 
-void SetRuleRequest::setResourceOwnerId(long resourceOwnerId)
+void SetRuleRequest::setCookie(const std::string& cookie)
 {
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	cookie_ = cookie;
+	setParameter("Cookie", cookie);
 }
 
 std::string SetRuleRequest::getResourceOwnerAccount()const
@@ -69,15 +201,26 @@ void SetRuleRequest::setResourceOwnerAccount(const std::string& resourceOwnerAcc
 	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
-std::string SetRuleRequest::getRegionId()const
+std::string SetRuleRequest::getStickySession()const
 {
-	return regionId_;
+	return stickySession_;
 }
 
-void SetRuleRequest::setRegionId(const std::string& regionId)
+void SetRuleRequest::setStickySession(const std::string& stickySession)
 {
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+	stickySession_ = stickySession;
+	setParameter("StickySession", stickySession);
+}
+
+std::string SetRuleRequest::getHealthCheckDomain()const
+{
+	return healthCheckDomain_;
+}
+
+void SetRuleRequest::setHealthCheckDomain(const std::string& healthCheckDomain)
+{
+	healthCheckDomain_ = healthCheckDomain;
+	setParameter("HealthCheckDomain", healthCheckDomain);
 }
 
 std::string SetRuleRequest::getOwnerAccount()const
@@ -102,17 +245,6 @@ void SetRuleRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
-std::string SetRuleRequest::getRuleId()const
-{
-	return ruleId_;
-}
-
-void SetRuleRequest::setRuleId(const std::string& ruleId)
-{
-	ruleId_ = ruleId;
-	setParameter("RuleId", ruleId);
-}
-
 std::string SetRuleRequest::getTags()const
 {
 	return tags_;
@@ -124,3 +256,47 @@ void SetRuleRequest::setTags(const std::string& tags)
 	setParameter("Tags", tags);
 }
 
+int SetRuleRequest::getHealthCheckInterval()const
+{
+	return healthCheckInterval_;
+}
+
+void SetRuleRequest::setHealthCheckInterval(int healthCheckInterval)
+{
+	healthCheckInterval_ = healthCheckInterval;
+	setParameter("HealthCheckInterval", std::to_string(healthCheckInterval));
+}
+
+std::string SetRuleRequest::getRuleId()const
+{
+	return ruleId_;
+}
+
+void SetRuleRequest::setRuleId(const std::string& ruleId)
+{
+	ruleId_ = ruleId;
+	setParameter("RuleId", ruleId);
+}
+
+int SetRuleRequest::getHealthCheckConnectPort()const
+{
+	return healthCheckConnectPort_;
+}
+
+void SetRuleRequest::setHealthCheckConnectPort(int healthCheckConnectPort)
+{
+	healthCheckConnectPort_ = healthCheckConnectPort;
+	setParameter("HealthCheckConnectPort", std::to_string(healthCheckConnectPort));
+}
+
+std::string SetRuleRequest::getHealthCheckHttpCode()const
+{
+	return healthCheckHttpCode_;
+}
+
+void SetRuleRequest::setHealthCheckHttpCode(const std::string& healthCheckHttpCode)
+{
+	healthCheckHttpCode_ = healthCheckHttpCode;
+	setParameter("HealthCheckHttpCode", healthCheckHttpCode);
+}
+

slb/src/model/SetVServerGroupAttributeResult.cc

@@ -40,37 +40,45 @@ void SetVServerGroupAttributeResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allBackendServers = value["BackendServers"]["BackendServer"];
-	for (auto value : allBackendServers)
-	{
-		BackendServer backendServersObject;
-		if(!value["ServerId"].isNull())
-			backendServersObject.serverId = value["ServerId"].asString();
-		if(!value["Port"].isNull())
-			backendServersObject.port = std::stoi(value["Port"].asString());
-		if(!value["Weight"].isNull())
-			backendServersObject.weight = std::stoi(value["Weight"].asString());
-		backendServers_.push_back(backendServersObject);
-	}
-	if(!value["VServerGroupId"].isNull())
-		vServerGroupId_ = value["VServerGroupId"].asString();
-	if(!value["VServerGroupName"].isNull())
-		vServerGroupName_ = value["VServerGroupName"].asString();
+	auto allBackendServers = value["BackendServers"]["BackendServer"];
+	for (auto value : allBackendServers)
+	{
+		BackendServer backendServersObject;
+		if(!value["ServerId"].isNull())
+			backendServersObject.serverId = value["ServerId"].asString();
+		if(!value["Port"].isNull())
+			backendServersObject.port = std::stoi(value["Port"].asString());
+		if(!value["Weight"].isNull())
+			backendServersObject.weight = std::stoi(value["Weight"].asString());
+		if(!value["Type"].isNull())
+			backendServersObject.type = value["Type"].asString();
+		if(!value["ServerIp"].isNull())
+			backendServersObject.serverIp = value["ServerIp"].asString();
+		if(!value["EniHost"].isNull())
+			backendServersObject.eniHost = value["EniHost"].asString();
+		if(!value["VpcId"].isNull())
+			backendServersObject.vpcId = value["VpcId"].asString();
+		backendServers_.push_back(backendServersObject);
+	}
+	if(!value["VServerGroupId"].isNull())
+		vServerGroupId_ = value["VServerGroupId"].asString();
+	if(!value["VServerGroupName"].isNull())
+		vServerGroupName_ = value["VServerGroupName"].asString();
 
 }
 
-std::string SetVServerGroupAttributeResult::getVServerGroupId()const
-{
-	return vServerGroupId_;
-}
-
-std::string SetVServerGroupAttributeResult::getVServerGroupName()const
-{
-	return vServerGroupName_;
-}
-
-std::vector<SetVServerGroupAttributeResult::BackendServer> SetVServerGroupAttributeResult::getBackendServers()const
-{
-	return backendServers_;
-}
-
+std::string SetVServerGroupAttributeResult::getVServerGroupId()const
+{
+	return vServerGroupId_;
+}
+
+std::string SetVServerGroupAttributeResult::getVServerGroupName()const
+{
+	return vServerGroupName_;
+}
+
+std::vector<SetVServerGroupAttributeResult::BackendServer> SetVServerGroupAttributeResult::getBackendServers()const
+{
+	return backendServers_;
+}
+

slb/src/model/UploadCACertificateResult.cc

@@ -40,48 +40,69 @@ void UploadCACertificateResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["CACertificateId"].isNull())
-		cACertificateId_ = value["CACertificateId"].asString();
-	if(!value["CACertificateName"].isNull())
-		cACertificateName_ = value["CACertificateName"].asString();
-	if(!value["Fingerprint"].isNull())
-		fingerprint_ = value["Fingerprint"].asString();
-	if(!value["ResourceGroupId"].isNull())
-		resourceGroupId_ = value["ResourceGroupId"].asString();
-	if(!value["CreateTime"].isNull())
-		createTime_ = value["CreateTime"].asString();
-	if(!value["CreateTimeStamp"].isNull())
-		createTimeStamp_ = std::stol(value["CreateTimeStamp"].asString());
+	if(!value["CACertificateId"].isNull())
+		cACertificateId_ = value["CACertificateId"].asString();
+	if(!value["CACertificateName"].isNull())
+		cACertificateName_ = value["CACertificateName"].asString();
+	if(!value["Fingerprint"].isNull())
+		fingerprint_ = value["Fingerprint"].asString();
+	if(!value["ResourceGroupId"].isNull())
+		resourceGroupId_ = value["ResourceGroupId"].asString();
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["CreateTimeStamp"].isNull())
+		createTimeStamp_ = std::stol(value["CreateTimeStamp"].asString());
+	if(!value["ExpireTime"].isNull())
+		expireTime_ = value["ExpireTime"].asString();
+	if(!value["ExpireTimeStamp"].isNull())
+		expireTimeStamp_ = std::stol(value["ExpireTimeStamp"].asString());
+	if(!value["CommonName"].isNull())
+		commonName_ = value["CommonName"].asString();
 
 }
 
-std::string UploadCACertificateResult::getFingerprint()const
-{
-	return fingerprint_;
-}
-
-std::string UploadCACertificateResult::getResourceGroupId()const
-{
-	return resourceGroupId_;
-}
-
-std::string UploadCACertificateResult::getCACertificateId()const
-{
-	return cACertificateId_;
-}
-
-std::string UploadCACertificateResult::getCreateTime()const
-{
-	return createTime_;
-}
-
-std::string UploadCACertificateResult::getCACertificateName()const
-{
-	return cACertificateName_;
-}
-
-long UploadCACertificateResult::getCreateTimeStamp()const
-{
-	return createTimeStamp_;
-}
-
+std::string UploadCACertificateResult::getFingerprint()const
+{
+	return fingerprint_;
+}
+
+std::string UploadCACertificateResult::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+long UploadCACertificateResult::getExpireTimeStamp()const
+{
+	return expireTimeStamp_;
+}
+
+std::string UploadCACertificateResult::getCACertificateId()const
+{
+	return cACertificateId_;
+}
+
+std::string UploadCACertificateResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+std::string UploadCACertificateResult::getCACertificateName()const
+{
+	return cACertificateName_;
+}
+
+std::string UploadCACertificateResult::getExpireTime()const
+{
+	return expireTime_;
+}
+
+long UploadCACertificateResult::getCreateTimeStamp()const
+{
+	return createTimeStamp_;
+}
+
+std::string UploadCACertificateResult::getCommonName()const
+{
+	return commonName_;
+}
+

slb/src/model/UploadServerCertificateResult.cc

@@ -40,83 +40,112 @@ void UploadServerCertificateResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["ServerCertificateId"].isNull())
-		serverCertificateId_ = value["ServerCertificateId"].asString();
-	if(!value["Fingerprint"].isNull())
-		fingerprint_ = value["Fingerprint"].asString();
-	if(!value["ServerCertificateName"].isNull())
-		serverCertificateName_ = value["ServerCertificateName"].asString();
-	if(!value["RegionId"].isNull())
-		regionId_ = value["RegionId"].asString();
-	if(!value["RegionIdAlias"].isNull())
-		regionIdAlias_ = value["RegionIdAlias"].asString();
-	if(!value["AliCloudCertificateId"].isNull())
-		aliCloudCertificateId_ = value["AliCloudCertificateId"].asString();
-	if(!value["AliCloudCertificateName"].isNull())
-		aliCloudCertificateName_ = value["AliCloudCertificateName"].asString();
-	if(!value["IsAliCloudCertificate"].isNull())
-		isAliCloudCertificate_ = std::stoi(value["IsAliCloudCertificate"].asString());
-	if(!value["ResourceGroupId"].isNull())
-		resourceGroupId_ = value["ResourceGroupId"].asString();
-	if(!value["CreateTime"].isNull())
-		createTime_ = value["CreateTime"].asString();
-	if(!value["CreateTimeStamp"].isNull())
-		createTimeStamp_ = std::stol(value["CreateTimeStamp"].asString());
+	auto allSubjectAlternativeNames = value["SubjectAlternativeNames"]["SubjectAlternativeName"];
+	for (const auto &item : allSubjectAlternativeNames)
+		subjectAlternativeNames_.push_back(item.asString());
+	if(!value["ServerCertificateId"].isNull())
+		serverCertificateId_ = value["ServerCertificateId"].asString();
+	if(!value["Fingerprint"].isNull())
+		fingerprint_ = value["Fingerprint"].asString();
+	if(!value["ServerCertificateName"].isNull())
+		serverCertificateName_ = value["ServerCertificateName"].asString();
+	if(!value["RegionId"].isNull())
+		regionId_ = value["RegionId"].asString();
+	if(!value["RegionIdAlias"].isNull())
+		regionIdAlias_ = value["RegionIdAlias"].asString();
+	if(!value["AliCloudCertificateId"].isNull())
+		aliCloudCertificateId_ = value["AliCloudCertificateId"].asString();
+	if(!value["AliCloudCertificateName"].isNull())
+		aliCloudCertificateName_ = value["AliCloudCertificateName"].asString();
+	if(!value["IsAliCloudCertificate"].isNull())
+		isAliCloudCertificate_ = std::stoi(value["IsAliCloudCertificate"].asString());
+	if(!value["ResourceGroupId"].isNull())
+		resourceGroupId_ = value["ResourceGroupId"].asString();
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["CreateTimeStamp"].isNull())
+		createTimeStamp_ = std::stol(value["CreateTimeStamp"].asString());
+	if(!value["ExpireTime"].isNull())
+		expireTime_ = value["ExpireTime"].asString();
+	if(!value["ExpireTimeStamp"].isNull())
+		expireTimeStamp_ = std::stol(value["ExpireTimeStamp"].asString());
+	if(!value["CommonName"].isNull())
+		commonName_ = value["CommonName"].asString();
 
 }
 
-std::string UploadServerCertificateResult::getRegionIdAlias()const
-{
-	return regionIdAlias_;
-}
-
-std::string UploadServerCertificateResult::getFingerprint()const
-{
-	return fingerprint_;
-}
-
-std::string UploadServerCertificateResult::getAliCloudCertificateName()const
-{
-	return aliCloudCertificateName_;
-}
-
-std::string UploadServerCertificateResult::getResourceGroupId()const
-{
-	return resourceGroupId_;
-}
-
-int UploadServerCertificateResult::getIsAliCloudCertificate()const
-{
-	return isAliCloudCertificate_;
-}
-
-std::string UploadServerCertificateResult::getCreateTime()const
-{
-	return createTime_;
-}
-
-std::string UploadServerCertificateResult::getServerCertificateId()const
-{
-	return serverCertificateId_;
-}
-
-std::string UploadServerCertificateResult::getServerCertificateName()const
-{
-	return serverCertificateName_;
-}
-
-std::string UploadServerCertificateResult::getRegionId()const
-{
-	return regionId_;
-}
-
-long UploadServerCertificateResult::getCreateTimeStamp()const
-{
-	return createTimeStamp_;
-}
-
-std::string UploadServerCertificateResult::getAliCloudCertificateId()const
-{
-	return aliCloudCertificateId_;
-}
-
+std::string UploadServerCertificateResult::getFingerprint()const
+{
+	return fingerprint_;
+}
+
+std::string UploadServerCertificateResult::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+long UploadServerCertificateResult::getExpireTimeStamp()const
+{
+	return expireTimeStamp_;
+}
+
+std::string UploadServerCertificateResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+std::vector<std::string> UploadServerCertificateResult::getSubjectAlternativeNames()const
+{
+	return subjectAlternativeNames_;
+}
+
+std::string UploadServerCertificateResult::getAliCloudCertificateId()const
+{
+	return aliCloudCertificateId_;
+}
+
+std::string UploadServerCertificateResult::getRegionIdAlias()const
+{
+	return regionIdAlias_;
+}
+
+std::string UploadServerCertificateResult::getAliCloudCertificateName()const
+{
+	return aliCloudCertificateName_;
+}
+
+int UploadServerCertificateResult::getIsAliCloudCertificate()const
+{
+	return isAliCloudCertificate_;
+}
+
+std::string UploadServerCertificateResult::getServerCertificateId()const
+{
+	return serverCertificateId_;
+}
+
+std::string UploadServerCertificateResult::getServerCertificateName()const
+{
+	return serverCertificateName_;
+}
+
+std::string UploadServerCertificateResult::getRegionId()const
+{
+	return regionId_;
+}
+
+std::string UploadServerCertificateResult::getExpireTime()const
+{
+	return expireTime_;
+}
+
+long UploadServerCertificateResult::getCreateTimeStamp()const
+{
+	return createTimeStamp_;
+}
+
+std::string UploadServerCertificateResult::getCommonName()const
+{
+	return commonName_;
+}
+