Generated 2014-05-15 for Slb.

slb/src/model/AddAccessControlListEntryRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * 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") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+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(std::string("access_key_id"), access_key_id);
+}
+
+long AddAccessControlListEntryRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void AddAccessControlListEntryRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string AddAccessControlListEntryRequest::getAclEntrys() const {
+  return aclEntrys_;
+}
+
+void AddAccessControlListEntryRequest::setAclEntrys(const std::string &aclEntrys) {
+  aclEntrys_ = aclEntrys;
+  setParameter(std::string("AclEntrys"), aclEntrys);
+}
+
+std::string AddAccessControlListEntryRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void AddAccessControlListEntryRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string AddAccessControlListEntryRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AddAccessControlListEntryRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string AddAccessControlListEntryRequest::getAclId() const {
+  return aclId_;
+}
+
+void AddAccessControlListEntryRequest::setAclId(const std::string &aclId) {
+  aclId_ = aclId;
+  setParameter(std::string("AclId"), aclId);
+}
+
+std::string AddAccessControlListEntryRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void AddAccessControlListEntryRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string AddAccessControlListEntryRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void AddAccessControlListEntryRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long AddAccessControlListEntryRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void AddAccessControlListEntryRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string AddAccessControlListEntryRequest::getTags() const {
+  return tags_;
+}
+
+void AddAccessControlListEntryRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+

slb/src/model/AddAccessControlListEntryResult.cc

@@ -0,0 +1,44 @@
+/*
+ * 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/AddBackendServersRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::Slb::Model::AddBackendServersRequest;
 
 AddBackendServersRequest::AddBackendServersRequest()
-    : RpcServiceRequest("slb", "2013-02-21", "AddBackendServers") {
+    : RpcServiceRequest("slb", "2014-05-15", "AddBackendServers") {
   setMethod(HttpRequest::Method::Post);
 }
 
@@ -52,13 +52,13 @@ void AddBackendServersRequest::setBackendServers(const std::string &backendServe
   setParameter(std::string("BackendServers"), backendServers);
 }
 
-std::string AddBackendServersRequest::getAccessKeyId() const {
-  return accessKeyId_;
+std::string AddBackendServersRequest::getRegionId() const {
+  return regionId_;
 }
 
-void AddBackendServersRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
+void AddBackendServersRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
 std::string AddBackendServersRequest::getResourceOwnerAccount() const {

slb/src/model/AddBackendServersResult.cc

@@ -43,8 +43,16 @@ void AddBackendServersResult::parse(const std::string &payload)
 	for (auto valueBackendServersBackendServer : allBackendServersNode)
 	{
 		BackendServer backendServersObject;
+		if(!valueBackendServersBackendServer["VpcId"].isNull())
+			backendServersObject.vpcId = valueBackendServersBackendServer["VpcId"].asString();
+		if(!valueBackendServersBackendServer["Type"].isNull())
+			backendServersObject.type = valueBackendServersBackendServer["Type"].asString();
 		if(!valueBackendServersBackendServer["Weight"].isNull())
 			backendServersObject.weight = valueBackendServersBackendServer["Weight"].asString();
+		if(!valueBackendServersBackendServer["Description"].isNull())
+			backendServersObject.description = valueBackendServersBackendServer["Description"].asString();
+		if(!valueBackendServersBackendServer["ServerIp"].isNull())
+			backendServersObject.serverIp = valueBackendServersBackendServer["ServerIp"].asString();
 		if(!valueBackendServersBackendServer["ServerId"].isNull())
 			backendServersObject.serverId = valueBackendServersBackendServer["ServerId"].asString();
 		backendServers_.push_back(backendServersObject);

slb/src/model/AddListenerWhiteListItemRequest.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/AddListenerWhiteListItemRequest.h>
+
+using AlibabaCloud::Slb::Model::AddListenerWhiteListItemRequest;
+
+AddListenerWhiteListItemRequest::AddListenerWhiteListItemRequest()
+    : RpcServiceRequest("slb", "2014-05-15", "AddListenerWhiteListItem") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AddListenerWhiteListItemRequest::~AddListenerWhiteListItemRequest() {}
+
+std::string AddListenerWhiteListItemRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void AddListenerWhiteListItemRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+long AddListenerWhiteListItemRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void AddListenerWhiteListItemRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string AddListenerWhiteListItemRequest::getSourceItems() const {
+  return sourceItems_;
+}
+
+void AddListenerWhiteListItemRequest::setSourceItems(const std::string &sourceItems) {
+  sourceItems_ = sourceItems;
+  setParameter(std::string("SourceItems"), sourceItems);
+}
+
+std::string AddListenerWhiteListItemRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AddListenerWhiteListItemRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+int AddListenerWhiteListItemRequest::getListenerPort() const {
+  return listenerPort_;
+}
+
+void AddListenerWhiteListItemRequest::setListenerPort(int listenerPort) {
+  listenerPort_ = listenerPort;
+  setParameter(std::string("ListenerPort"), std::to_string(listenerPort));
+}
+
+std::string AddListenerWhiteListItemRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void AddListenerWhiteListItemRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string AddListenerWhiteListItemRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void AddListenerWhiteListItemRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long AddListenerWhiteListItemRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void AddListenerWhiteListItemRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string AddListenerWhiteListItemRequest::getListenerProtocol() const {
+  return listenerProtocol_;
+}
+
+void AddListenerWhiteListItemRequest::setListenerProtocol(const std::string &listenerProtocol) {
+  listenerProtocol_ = listenerProtocol;
+  setParameter(std::string("ListenerProtocol"), listenerProtocol);
+}
+
+std::string AddListenerWhiteListItemRequest::getTags() const {
+  return tags_;
+}
+
+void AddListenerWhiteListItemRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+
+std::string AddListenerWhiteListItemRequest::getLoadBalancerId() const {
+  return loadBalancerId_;
+}
+
+void AddListenerWhiteListItemRequest::setLoadBalancerId(const std::string &loadBalancerId) {
+  loadBalancerId_ = loadBalancerId;
+  setParameter(std::string("LoadBalancerId"), loadBalancerId);
+}
+

slb/src/model/AddListenerWhiteListItemResult.cc

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

slb/src/model/AddTagsRequest.cc

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

slb/src/model/AddTagsResult.cc

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

slb/src/model/AddVServerGroupBackendServersRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * 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/AddVServerGroupBackendServersRequest.h>
+
+using AlibabaCloud::Slb::Model::AddVServerGroupBackendServersRequest;
+
+AddVServerGroupBackendServersRequest::AddVServerGroupBackendServersRequest()
+    : RpcServiceRequest("slb", "2014-05-15", "AddVServerGroupBackendServers") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AddVServerGroupBackendServersRequest::~AddVServerGroupBackendServersRequest() {}
+
+std::string AddVServerGroupBackendServersRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void AddVServerGroupBackendServersRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+long AddVServerGroupBackendServersRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void AddVServerGroupBackendServersRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string AddVServerGroupBackendServersRequest::getBackendServers() const {
+  return backendServers_;
+}
+
+void AddVServerGroupBackendServersRequest::setBackendServers(const std::string &backendServers) {
+  backendServers_ = backendServers;
+  setParameter(std::string("BackendServers"), backendServers);
+}
+
+std::string AddVServerGroupBackendServersRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AddVServerGroupBackendServersRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string AddVServerGroupBackendServersRequest::getVServerGroupId() const {
+  return vServerGroupId_;
+}
+
+void AddVServerGroupBackendServersRequest::setVServerGroupId(const std::string &vServerGroupId) {
+  vServerGroupId_ = vServerGroupId;
+  setParameter(std::string("VServerGroupId"), vServerGroupId);
+}
+
+std::string AddVServerGroupBackendServersRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void AddVServerGroupBackendServersRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string AddVServerGroupBackendServersRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void AddVServerGroupBackendServersRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long AddVServerGroupBackendServersRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void AddVServerGroupBackendServersRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string AddVServerGroupBackendServersRequest::getTags() const {
+  return tags_;
+}
+
+void AddVServerGroupBackendServersRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+

slb/src/model/AddVServerGroupBackendServersResult.cc

@@ -0,0 +1,80 @@
+/*
+ * 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/AddVServerGroupBackendServersResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+AddVServerGroupBackendServersResult::AddVServerGroupBackendServersResult() :
+	ServiceResult()
+{}
+
+AddVServerGroupBackendServersResult::AddVServerGroupBackendServersResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AddVServerGroupBackendServersResult::~AddVServerGroupBackendServersResult()
+{}
+
+void AddVServerGroupBackendServersResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allBackendServersNode = value["BackendServers"]["BackendServer"];
+	for (auto valueBackendServersBackendServer : allBackendServersNode)
+	{
+		BackendServer backendServersObject;
+		if(!valueBackendServersBackendServer["VpcId"].isNull())
+			backendServersObject.vpcId = valueBackendServersBackendServer["VpcId"].asString();
+		if(!valueBackendServersBackendServer["Type"].isNull())
+			backendServersObject.type = valueBackendServersBackendServer["Type"].asString();
+		if(!valueBackendServersBackendServer["Weight"].isNull())
+			backendServersObject.weight = std::stoi(valueBackendServersBackendServer["Weight"].asString());
+		if(!valueBackendServersBackendServer["Description"].isNull())
+			backendServersObject.description = valueBackendServersBackendServer["Description"].asString();
+		if(!valueBackendServersBackendServer["ServerRegionId"].isNull())
+			backendServersObject.serverRegionId = valueBackendServersBackendServer["ServerRegionId"].asString();
+		if(!valueBackendServersBackendServer["ServerIp"].isNull())
+			backendServersObject.serverIp = valueBackendServersBackendServer["ServerIp"].asString();
+		if(!valueBackendServersBackendServer["Port"].isNull())
+			backendServersObject.port = std::stoi(valueBackendServersBackendServer["Port"].asString());
+		if(!valueBackendServersBackendServer["VbrId"].isNull())
+			backendServersObject.vbrId = valueBackendServersBackendServer["VbrId"].asString();
+		if(!valueBackendServersBackendServer["ServerId"].isNull())
+			backendServersObject.serverId = valueBackendServersBackendServer["ServerId"].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_;
+}
+

slb/src/model/CreateAccessControlListRequest.cc

@@ -0,0 +1,140 @@
+/*
+ * 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") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+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(std::string("access_key_id"), access_key_id);
+}
+
+long CreateAccessControlListRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateAccessControlListRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreateAccessControlListRequest::getAclName() const {
+  return aclName_;
+}
+
+void CreateAccessControlListRequest::setAclName(const std::string &aclName) {
+  aclName_ = aclName;
+  setParameter(std::string("AclName"), aclName);
+}
+
+std::string CreateAccessControlListRequest::getAddressIPVersion() const {
+  return addressIPVersion_;
+}
+
+void CreateAccessControlListRequest::setAddressIPVersion(const std::string &addressIPVersion) {
+  addressIPVersion_ = addressIPVersion;
+  setParameter(std::string("AddressIPVersion"), addressIPVersion);
+}
+
+std::string CreateAccessControlListRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void CreateAccessControlListRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string CreateAccessControlListRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void CreateAccessControlListRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
+std::string CreateAccessControlListRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateAccessControlListRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::vector<CreateAccessControlListRequest::Tag> CreateAccessControlListRequest::getTag() const {
+  return tag_;
+}
+
+void CreateAccessControlListRequest::setTag(const std::vector<CreateAccessControlListRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
+std::string CreateAccessControlListRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreateAccessControlListRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CreateAccessControlListRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreateAccessControlListRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long CreateAccessControlListRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateAccessControlListRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateAccessControlListRequest::getTags() const {
+  return tags_;
+}
+
+void CreateAccessControlListRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+

slb/src/model/CreateAccessControlListResult.cc

@@ -0,0 +1,51 @@
+/*
+ * 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,149 @@
+/*
+ * 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") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+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(std::string("access_key_id"), access_key_id);
+}
+
+long CreateDomainExtensionRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateDomainExtensionRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::vector<CreateDomainExtensionRequest::ServerCertificate> CreateDomainExtensionRequest::getServerCertificate() const {
+  return serverCertificate_;
+}
+
+void CreateDomainExtensionRequest::setServerCertificate(const std::vector<CreateDomainExtensionRequest::ServerCertificate> &serverCertificate) {
+  serverCertificate_ = serverCertificate;
+  for(int dep1 = 0; dep1 != serverCertificate.size(); dep1++) {
+  auto serverCertificateObj = serverCertificate.at(dep1);
+  std::string serverCertificateObjStr = std::string("ServerCertificate") + "." + std::to_string(dep1 + 1);
+    setParameter(serverCertificateObjStr + ".BindingType", serverCertificateObj.bindingType);
+    setParameter(serverCertificateObjStr + ".CertificateId", serverCertificateObj.certificateId);
+    setParameter(serverCertificateObjStr + ".StandardType", serverCertificateObj.standardType);
+  }
+}
+
+std::string CreateDomainExtensionRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateDomainExtensionRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+int CreateDomainExtensionRequest::getListenerPort() const {
+  return listenerPort_;
+}
+
+void CreateDomainExtensionRequest::setListenerPort(int listenerPort) {
+  listenerPort_ = listenerPort;
+  setParameter(std::string("ListenerPort"), std::to_string(listenerPort));
+}
+
+std::string CreateDomainExtensionRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreateDomainExtensionRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CreateDomainExtensionRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreateDomainExtensionRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::vector<std::string> CreateDomainExtensionRequest::getCertificateId() const {
+  return certificateId_;
+}
+
+void CreateDomainExtensionRequest::setCertificateId(const std::vector<std::string> &certificateId) {
+  certificateId_ = certificateId;
+}
+
+long CreateDomainExtensionRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateDomainExtensionRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateDomainExtensionRequest::getServerCertificateId() const {
+  return serverCertificateId_;
+}
+
+void CreateDomainExtensionRequest::setServerCertificateId(const std::string &serverCertificateId) {
+  serverCertificateId_ = serverCertificateId;
+  setParameter(std::string("ServerCertificateId"), serverCertificateId);
+}
+
+std::string CreateDomainExtensionRequest::getTags() const {
+  return tags_;
+}
+
+void CreateDomainExtensionRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+
+std::string CreateDomainExtensionRequest::getLoadBalancerId() const {
+  return loadBalancerId_;
+}
+
+void CreateDomainExtensionRequest::setLoadBalancerId(const std::string &loadBalancerId) {
+  loadBalancerId_ = loadBalancerId;
+  setParameter(std::string("LoadBalancerId"), loadBalancerId);
+}
+
+std::string CreateDomainExtensionRequest::getDomain() const {
+  return domain_;
+}
+
+void CreateDomainExtensionRequest::setDomain(const std::string &domain) {
+  domain_ = domain;
+  setParameter(std::string("Domain"), domain);
+}
+

slb/src/model/CreateDomainExtensionResult.cc

@@ -0,0 +1,58 @@
+/*
+ * 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

@@ -19,7 +19,7 @@
 using AlibabaCloud::Slb::Model::CreateLoadBalancerHTTPListenerRequest;
 
 CreateLoadBalancerHTTPListenerRequest::CreateLoadBalancerHTTPListenerRequest()
-    : RpcServiceRequest("slb", "2013-02-21", "CreateLoadBalancerHTTPListener") {
+    : RpcServiceRequest("slb", "2014-05-15", "CreateLoadBalancerHTTPListener") {
   setMethod(HttpRequest::Method::Post);
 }
 
@@ -43,6 +43,15 @@ void CreateLoadBalancerHTTPListenerRequest::setHealthCheckTimeout(int healthChec
   setParameter(std::string("HealthCheckTimeout"), std::to_string(healthCheckTimeout));
 }
 
+std::string CreateLoadBalancerHTTPListenerRequest::getListenerForward() const {
+  return listenerForward_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setListenerForward(const std::string &listenerForward) {
+  listenerForward_ = listenerForward;
+  setParameter(std::string("ListenerForward"), listenerForward);
+}
+
 std::string CreateLoadBalancerHTTPListenerRequest::getXForwardedFor() const {
   return xForwardedFor_;
 }
@@ -52,13 +61,234 @@ void CreateLoadBalancerHTTPListenerRequest::setXForwardedFor(const std::string &
   setParameter(std::string("XForwardedFor"), xForwardedFor);
 }
 
-std::string CreateLoadBalancerHTTPListenerRequest::getHostId() const {
-  return hostId_;
+std::string CreateLoadBalancerHTTPListenerRequest::getHealthCheckURI() const {
+  return healthCheckURI_;
 }
 
-void CreateLoadBalancerHTTPListenerRequest::setHostId(const std::string &hostId) {
-  hostId_ = hostId;
-  setParameter(std::string("HostId"), hostId);
+void CreateLoadBalancerHTTPListenerRequest::setHealthCheckURI(const std::string &healthCheckURI) {
+  healthCheckURI_ = healthCheckURI;
+  setParameter(std::string("HealthCheckURI"), healthCheckURI);
+}
+
+std::string CreateLoadBalancerHTTPListenerRequest::getXForwardedFor_SLBPORT() const {
+  return xForwardedFor_SLBPORT_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setXForwardedFor_SLBPORT(const std::string &xForwardedFor_SLBPORT) {
+  xForwardedFor_SLBPORT_ = xForwardedFor_SLBPORT;
+  setParameter(std::string("XForwardedFor_SLBPORT"), xForwardedFor_SLBPORT);
+}
+
+std::string CreateLoadBalancerHTTPListenerRequest::getAclStatus() const {
+  return aclStatus_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setAclStatus(const std::string &aclStatus) {
+  aclStatus_ = aclStatus;
+  setParameter(std::string("AclStatus"), aclStatus);
+}
+
+std::string CreateLoadBalancerHTTPListenerRequest::getAclType() const {
+  return aclType_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setAclType(const std::string &aclType) {
+  aclType_ = aclType;
+  setParameter(std::string("AclType"), aclType);
+}
+
+std::string CreateLoadBalancerHTTPListenerRequest::getHealthCheck() const {
+  return healthCheck_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setHealthCheck(const std::string &healthCheck) {
+  healthCheck_ = healthCheck;
+  setParameter(std::string("HealthCheck"), healthCheck);
+}
+
+std::string CreateLoadBalancerHTTPListenerRequest::getVpcIds() const {
+  return vpcIds_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setVpcIds(const std::string &vpcIds) {
+  vpcIds_ = vpcIds;
+  setParameter(std::string("VpcIds"), vpcIds);
+}
+
+std::vector<CreateLoadBalancerHTTPListenerRequest::Tag> CreateLoadBalancerHTTPListenerRequest::getTag() const {
+  return tag_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setTag(const std::vector<CreateLoadBalancerHTTPListenerRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
+std::string CreateLoadBalancerHTTPListenerRequest::getVServerGroupId() const {
+  return vServerGroupId_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setVServerGroupId(const std::string &vServerGroupId) {
+  vServerGroupId_ = vServerGroupId;
+  setParameter(std::string("VServerGroupId"), vServerGroupId);
+}
+
+std::string CreateLoadBalancerHTTPListenerRequest::getAclId() const {
+  return aclId_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setAclId(const std::string &aclId) {
+  aclId_ = aclId;
+  setParameter(std::string("AclId"), aclId);
+}
+
+int CreateLoadBalancerHTTPListenerRequest::getForwardCode() const {
+  return forwardCode_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setForwardCode(int forwardCode) {
+  forwardCode_ = forwardCode;
+  setParameter(std::string("ForwardCode"), std::to_string(forwardCode));
+}
+
+std::string CreateLoadBalancerHTTPListenerRequest::getCookie() const {
+  return cookie_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setCookie(const std::string &cookie) {
+  cookie_ = cookie;
+  setParameter(std::string("Cookie"), cookie);
+}
+
+std::string CreateLoadBalancerHTTPListenerRequest::getHealthCheckMethod() const {
+  return healthCheckMethod_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setHealthCheckMethod(const std::string &healthCheckMethod) {
+  healthCheckMethod_ = healthCheckMethod;
+  setParameter(std::string("HealthCheckMethod"), healthCheckMethod);
+}
+
+std::string CreateLoadBalancerHTTPListenerRequest::getHealthCheckDomain() const {
+  return healthCheckDomain_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setHealthCheckDomain(const std::string &healthCheckDomain) {
+  healthCheckDomain_ = healthCheckDomain;
+  setParameter(std::string("HealthCheckDomain"), healthCheckDomain);
+}
+
+int CreateLoadBalancerHTTPListenerRequest::getRequestTimeout() const {
+  return requestTimeout_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setRequestTimeout(int requestTimeout) {
+  requestTimeout_ = requestTimeout;
+  setParameter(std::string("RequestTimeout"), std::to_string(requestTimeout));
+}
+
+long CreateLoadBalancerHTTPListenerRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateLoadBalancerHTTPListenerRequest::getTags() const {
+  return tags_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+
+std::string CreateLoadBalancerHTTPListenerRequest::getLoadBalancerId() const {
+  return loadBalancerId_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setLoadBalancerId(const std::string &loadBalancerId) {
+  loadBalancerId_ = loadBalancerId;
+  setParameter(std::string("LoadBalancerId"), loadBalancerId);
+}
+
+std::string CreateLoadBalancerHTTPListenerRequest::getXForwardedFor_SLBIP() const {
+  return xForwardedFor_SLBIP_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setXForwardedFor_SLBIP(const std::string &xForwardedFor_SLBIP) {
+  xForwardedFor_SLBIP_ = xForwardedFor_SLBIP;
+  setParameter(std::string("XForwardedFor_SLBIP"), xForwardedFor_SLBIP);
+}
+
+int CreateLoadBalancerHTTPListenerRequest::getBackendServerPort() const {
+  return backendServerPort_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setBackendServerPort(int backendServerPort) {
+  backendServerPort_ = backendServerPort;
+  setParameter(std::string("BackendServerPort"), std::to_string(backendServerPort));
+}
+
+int CreateLoadBalancerHTTPListenerRequest::getHealthCheckInterval() const {
+  return healthCheckInterval_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setHealthCheckInterval(int healthCheckInterval) {
+  healthCheckInterval_ = healthCheckInterval;
+  setParameter(std::string("HealthCheckInterval"), std::to_string(healthCheckInterval));
+}
+
+std::string CreateLoadBalancerHTTPListenerRequest::getXForwardedFor_SLBID() const {
+  return xForwardedFor_SLBID_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setXForwardedFor_SLBID(const std::string &xForwardedFor_SLBID) {
+  xForwardedFor_SLBID_ = xForwardedFor_SLBID;
+  setParameter(std::string("XForwardedFor_SLBID"), xForwardedFor_SLBID);
+}
+
+std::string CreateLoadBalancerHTTPListenerRequest::getHealthCheckHttpVersion() const {
+  return healthCheckHttpVersion_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setHealthCheckHttpVersion(const std::string &healthCheckHttpVersion) {
+  healthCheckHttpVersion_ = healthCheckHttpVersion;
+  setParameter(std::string("HealthCheckHttpVersion"), healthCheckHttpVersion);
+}
+
+std::string CreateLoadBalancerHTTPListenerRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+std::string CreateLoadBalancerHTTPListenerRequest::getXForwardedFor_ClientSrcPort() const {
+  return xForwardedFor_ClientSrcPort_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setXForwardedFor_ClientSrcPort(const std::string &xForwardedFor_ClientSrcPort) {
+  xForwardedFor_ClientSrcPort_ = xForwardedFor_ClientSrcPort;
+  setParameter(std::string("XForwardedFor_ClientSrcPort"), xForwardedFor_ClientSrcPort);
+}
+
+std::string CreateLoadBalancerHTTPListenerRequest::getDescription() const {
+  return description_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
 int CreateLoadBalancerHTTPListenerRequest::getUnhealthyThreshold() const {
@@ -79,15 +309,6 @@ void CreateLoadBalancerHTTPListenerRequest::setHealthyThreshold(int healthyThres
   setParameter(std::string("HealthyThreshold"), std::to_string(healthyThreshold));
 }
 
-std::string CreateLoadBalancerHTTPListenerRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void CreateLoadBalancerHTTPListenerRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
 std::string CreateLoadBalancerHTTPListenerRequest::getScheduler() const {
   return scheduler_;
 }
@@ -97,13 +318,31 @@ void CreateLoadBalancerHTTPListenerRequest::setScheduler(const std::string &sche
   setParameter(std::string("Scheduler"), scheduler);
 }
 
-std::string CreateLoadBalancerHTTPListenerRequest::getHealthCheck() const {
-  return healthCheck_;
+int CreateLoadBalancerHTTPListenerRequest::getForwardPort() const {
+  return forwardPort_;
 }
 
-void CreateLoadBalancerHTTPListenerRequest::setHealthCheck(const std::string &healthCheck) {
-  healthCheck_ = healthCheck;
-  setParameter(std::string("HealthCheck"), healthCheck);
+void CreateLoadBalancerHTTPListenerRequest::setForwardPort(int forwardPort) {
+  forwardPort_ = forwardPort;
+  setParameter(std::string("ForwardPort"), std::to_string(forwardPort));
+}
+
+int CreateLoadBalancerHTTPListenerRequest::getMaxConnection() const {
+  return maxConnection_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setMaxConnection(int maxConnection) {
+  maxConnection_ = maxConnection;
+  setParameter(std::string("MaxConnection"), std::to_string(maxConnection));
+}
+
+std::string CreateLoadBalancerHTTPListenerRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
 int CreateLoadBalancerHTTPListenerRequest::getCookieTimeout() const {
@@ -133,22 +372,22 @@ void CreateLoadBalancerHTTPListenerRequest::setListenerPort(int listenerPort) {
   setParameter(std::string("ListenerPort"), std::to_string(listenerPort));
 }
 
-std::string CreateLoadBalancerHTTPListenerRequest::getCookie() const {
-  return cookie_;
+std::string CreateLoadBalancerHTTPListenerRequest::getHealthCheckType() const {
+  return healthCheckType_;
 }
 
-void CreateLoadBalancerHTTPListenerRequest::setCookie(const std::string &cookie) {
-  cookie_ = cookie;
-  setParameter(std::string("Cookie"), cookie);
+void CreateLoadBalancerHTTPListenerRequest::setHealthCheckType(const std::string &healthCheckType) {
+  healthCheckType_ = healthCheckType;
+  setParameter(std::string("HealthCheckType"), healthCheckType);
 }
 
-std::string CreateLoadBalancerHTTPListenerRequest::getStickySession() const {
-  return stickySession_;
+std::string CreateLoadBalancerHTTPListenerRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-void CreateLoadBalancerHTTPListenerRequest::setStickySession(const std::string &stickySession) {
-  stickySession_ = stickySession;
-  setParameter(std::string("StickySession"), stickySession);
+void CreateLoadBalancerHTTPListenerRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
 int CreateLoadBalancerHTTPListenerRequest::getBandwidth() const {
@@ -160,6 +399,15 @@ void CreateLoadBalancerHTTPListenerRequest::setBandwidth(int bandwidth) {
   setParameter(std::string("Bandwidth"), std::to_string(bandwidth));
 }
 
+std::string CreateLoadBalancerHTTPListenerRequest::getStickySession() const {
+  return stickySession_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setStickySession(const std::string &stickySession) {
+  stickySession_ = stickySession;
+  setParameter(std::string("StickySession"), stickySession);
+}
+
 std::string CreateLoadBalancerHTTPListenerRequest::getOwnerAccount() const {
   return ownerAccount_;
 }
@@ -169,66 +417,48 @@ void CreateLoadBalancerHTTPListenerRequest::setOwnerAccount(const std::string &o
   setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-std::string CreateLoadBalancerHTTPListenerRequest::getOwnerId() const {
-  return ownerId_;
+std::string CreateLoadBalancerHTTPListenerRequest::getGzip() const {
+  return gzip_;
 }
 
-void CreateLoadBalancerHTTPListenerRequest::setOwnerId(const std::string &ownerId) {
-  ownerId_ = ownerId;
-  setParameter(std::string("OwnerId"), ownerId);
+void CreateLoadBalancerHTTPListenerRequest::setGzip(const std::string &gzip) {
+  gzip_ = gzip;
+  setParameter(std::string("Gzip"), gzip);
 }
 
-std::string CreateLoadBalancerHTTPListenerRequest::getURI() const {
-  return uRI_;
+int CreateLoadBalancerHTTPListenerRequest::getIdleTimeout() const {
+  return idleTimeout_;
 }
 
-void CreateLoadBalancerHTTPListenerRequest::setURI(const std::string &uRI) {
-  uRI_ = uRI;
-  setParameter(std::string("URI"), uRI);
+void CreateLoadBalancerHTTPListenerRequest::setIdleTimeout(int idleTimeout) {
+  idleTimeout_ = idleTimeout;
+  setParameter(std::string("IdleTimeout"), std::to_string(idleTimeout));
 }
 
-std::string CreateLoadBalancerHTTPListenerRequest::getListenerStatus() const {
-  return listenerStatus_;
+std::string CreateLoadBalancerHTTPListenerRequest::getXForwardedFor_proto() const {
+  return xForwardedFor_proto_;
 }
 
-void CreateLoadBalancerHTTPListenerRequest::setListenerStatus(const std::string &listenerStatus) {
-  listenerStatus_ = listenerStatus;
-  setParameter(std::string("ListenerStatus"), listenerStatus);
+void CreateLoadBalancerHTTPListenerRequest::setXForwardedFor_proto(const std::string &xForwardedFor_proto) {
+  xForwardedFor_proto_ = xForwardedFor_proto;
+  setParameter(std::string("XForwardedFor_proto"), xForwardedFor_proto);
 }
 
-std::string CreateLoadBalancerHTTPListenerRequest::getLoadBalancerId() const {
-  return loadBalancerId_;
+int CreateLoadBalancerHTTPListenerRequest::getHealthCheckConnectPort() const {
+  return healthCheckConnectPort_;
 }
 
-void CreateLoadBalancerHTTPListenerRequest::setLoadBalancerId(const std::string &loadBalancerId) {
-  loadBalancerId_ = loadBalancerId;
-  setParameter(std::string("LoadBalancerId"), loadBalancerId);
+void CreateLoadBalancerHTTPListenerRequest::setHealthCheckConnectPort(int healthCheckConnectPort) {
+  healthCheckConnectPort_ = healthCheckConnectPort;
+  setParameter(std::string("HealthCheckConnectPort"), std::to_string(healthCheckConnectPort));
 }
 
-int CreateLoadBalancerHTTPListenerRequest::getBackendServerPort() const {
-  return backendServerPort_;
+std::string CreateLoadBalancerHTTPListenerRequest::getHealthCheckHttpCode() const {
+  return healthCheckHttpCode_;
 }
 
-void CreateLoadBalancerHTTPListenerRequest::setBackendServerPort(int backendServerPort) {
-  backendServerPort_ = backendServerPort;
-  setParameter(std::string("BackendServerPort"), std::to_string(backendServerPort));
-}
-
-std::string CreateLoadBalancerHTTPListenerRequest::getDomain() const {
-  return domain_;
-}
-
-void CreateLoadBalancerHTTPListenerRequest::setDomain(const std::string &domain) {
-  domain_ = domain;
-  setParameter(std::string("Domain"), domain);
-}
-
-int CreateLoadBalancerHTTPListenerRequest::getInterval() const {
-  return interval_;
-}
-
-void CreateLoadBalancerHTTPListenerRequest::setInterval(int interval) {
-  interval_ = interval;
-  setParameter(std::string("Interval"), std::to_string(interval));
+void CreateLoadBalancerHTTPListenerRequest::setHealthCheckHttpCode(const std::string &healthCheckHttpCode) {
+  healthCheckHttpCode_ = healthCheckHttpCode;
+  setParameter(std::string("HealthCheckHttpCode"), healthCheckHttpCode);
 }
 

slb/src/model/CreateLoadBalancerHTTPSListenerRequest.cc

@@ -0,0 +1,569 @@
+/*
+ * 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/CreateLoadBalancerHTTPSListenerRequest.h>
+
+using AlibabaCloud::Slb::Model::CreateLoadBalancerHTTPSListenerRequest;
+
+CreateLoadBalancerHTTPSListenerRequest::CreateLoadBalancerHTTPSListenerRequest()
+    : RpcServiceRequest("slb", "2014-05-15", "CreateLoadBalancerHTTPSListener") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateLoadBalancerHTTPSListenerRequest::~CreateLoadBalancerHTTPSListenerRequest() {}
+
+long CreateLoadBalancerHTTPSListenerRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::vector<CreateLoadBalancerHTTPSListenerRequest::ServerCertificate> CreateLoadBalancerHTTPSListenerRequest::getServerCertificate() const {
+  return serverCertificate_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setServerCertificate(const std::vector<CreateLoadBalancerHTTPSListenerRequest::ServerCertificate> &serverCertificate) {
+  serverCertificate_ = serverCertificate;
+  for(int dep1 = 0; dep1 != serverCertificate.size(); dep1++) {
+  auto serverCertificateObj = serverCertificate.at(dep1);
+  std::string serverCertificateObjStr = std::string("ServerCertificate") + "." + std::to_string(dep1 + 1);
+    setParameter(serverCertificateObjStr + ".BindingType", serverCertificateObj.bindingType);
+    setParameter(serverCertificateObjStr + ".CertificateId", serverCertificateObj.certificateId);
+    setParameter(serverCertificateObjStr + ".StandardType", serverCertificateObj.standardType);
+  }
+}
+
+int CreateLoadBalancerHTTPSListenerRequest::getHealthCheckTimeout() const {
+  return healthCheckTimeout_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckTimeout(int healthCheckTimeout) {
+  healthCheckTimeout_ = healthCheckTimeout;
+  setParameter(std::string("HealthCheckTimeout"), std::to_string(healthCheckTimeout));
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getXForwardedFor() const {
+  return xForwardedFor_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setXForwardedFor(const std::string &xForwardedFor) {
+  xForwardedFor_ = xForwardedFor;
+  setParameter(std::string("XForwardedFor"), xForwardedFor);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getHealthCheckURI() const {
+  return healthCheckURI_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckURI(const std::string &healthCheckURI) {
+  healthCheckURI_ = healthCheckURI;
+  setParameter(std::string("HealthCheckURI"), healthCheckURI);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getXForwardedFor_SLBPORT() const {
+  return xForwardedFor_SLBPORT_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setXForwardedFor_SLBPORT(const std::string &xForwardedFor_SLBPORT) {
+  xForwardedFor_SLBPORT_ = xForwardedFor_SLBPORT;
+  setParameter(std::string("XForwardedFor_SLBPORT"), xForwardedFor_SLBPORT);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getAclStatus() const {
+  return aclStatus_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setAclStatus(const std::string &aclStatus) {
+  aclStatus_ = aclStatus;
+  setParameter(std::string("AclStatus"), aclStatus);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getAclType() const {
+  return aclType_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setAclType(const std::string &aclType) {
+  aclType_ = aclType;
+  setParameter(std::string("AclType"), aclType);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getHealthCheck() const {
+  return healthCheck_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setHealthCheck(const std::string &healthCheck) {
+  healthCheck_ = healthCheck;
+  setParameter(std::string("HealthCheck"), healthCheck);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getVpcIds() const {
+  return vpcIds_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setVpcIds(const std::string &vpcIds) {
+  vpcIds_ = vpcIds;
+  setParameter(std::string("VpcIds"), vpcIds);
+}
+
+std::vector<CreateLoadBalancerHTTPSListenerRequest::Tag> CreateLoadBalancerHTTPSListenerRequest::getTag() const {
+  return tag_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setTag(const std::vector<CreateLoadBalancerHTTPSListenerRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getVServerGroupId() const {
+  return vServerGroupId_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setVServerGroupId(const std::string &vServerGroupId) {
+  vServerGroupId_ = vServerGroupId;
+  setParameter(std::string("VServerGroupId"), vServerGroupId);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getAclId() const {
+  return aclId_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setAclId(const std::string &aclId) {
+  aclId_ = aclId;
+  setParameter(std::string("AclId"), aclId);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getXForwardedFor_ClientCertClientVerify() const {
+  return xForwardedFor_ClientCertClientVerify_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setXForwardedFor_ClientCertClientVerify(const std::string &xForwardedFor_ClientCertClientVerify) {
+  xForwardedFor_ClientCertClientVerify_ = xForwardedFor_ClientCertClientVerify;
+  setParameter(std::string("XForwardedFor_ClientCertClientVerify"), xForwardedFor_ClientCertClientVerify);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getCookie() const {
+  return cookie_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setCookie(const std::string &cookie) {
+  cookie_ = cookie;
+  setParameter(std::string("Cookie"), cookie);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getHealthCheckMethod() const {
+  return healthCheckMethod_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckMethod(const std::string &healthCheckMethod) {
+  healthCheckMethod_ = healthCheckMethod;
+  setParameter(std::string("HealthCheckMethod"), healthCheckMethod);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getHealthCheckDomain() const {
+  return healthCheckDomain_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckDomain(const std::string &healthCheckDomain) {
+  healthCheckDomain_ = healthCheckDomain;
+  setParameter(std::string("HealthCheckDomain"), healthCheckDomain);
+}
+
+int CreateLoadBalancerHTTPSListenerRequest::getRequestTimeout() const {
+  return requestTimeout_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setRequestTimeout(int requestTimeout) {
+  requestTimeout_ = requestTimeout;
+  setParameter(std::string("RequestTimeout"), std::to_string(requestTimeout));
+}
+
+long CreateLoadBalancerHTTPSListenerRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getCACertificateId() const {
+  return cACertificateId_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setCACertificateId(const std::string &cACertificateId) {
+  cACertificateId_ = cACertificateId;
+  setParameter(std::string("CACertificateId"), cACertificateId);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getBackendProtocol() const {
+  return backendProtocol_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setBackendProtocol(const std::string &backendProtocol) {
+  backendProtocol_ = backendProtocol;
+  setParameter(std::string("BackendProtocol"), backendProtocol);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getTags() const {
+  return tags_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getXForwardedFor_ClientCertFingerprintAlias() const {
+  return xForwardedFor_ClientCertFingerprintAlias_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setXForwardedFor_ClientCertFingerprintAlias(const std::string &xForwardedFor_ClientCertFingerprintAlias) {
+  xForwardedFor_ClientCertFingerprintAlias_ = xForwardedFor_ClientCertFingerprintAlias;
+  setParameter(std::string("XForwardedFor_ClientCertFingerprintAlias"), xForwardedFor_ClientCertFingerprintAlias);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getLoadBalancerId() const {
+  return loadBalancerId_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setLoadBalancerId(const std::string &loadBalancerId) {
+  loadBalancerId_ = loadBalancerId;
+  setParameter(std::string("LoadBalancerId"), loadBalancerId);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getXForwardedFor_SLBIP() const {
+  return xForwardedFor_SLBIP_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setXForwardedFor_SLBIP(const std::string &xForwardedFor_SLBIP) {
+  xForwardedFor_SLBIP_ = xForwardedFor_SLBIP;
+  setParameter(std::string("XForwardedFor_SLBIP"), xForwardedFor_SLBIP);
+}
+
+int CreateLoadBalancerHTTPSListenerRequest::getBackendServerPort() const {
+  return backendServerPort_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setBackendServerPort(int backendServerPort) {
+  backendServerPort_ = backendServerPort;
+  setParameter(std::string("BackendServerPort"), std::to_string(backendServerPort));
+}
+
+int CreateLoadBalancerHTTPSListenerRequest::getHealthCheckInterval() const {
+  return healthCheckInterval_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckInterval(int healthCheckInterval) {
+  healthCheckInterval_ = healthCheckInterval;
+  setParameter(std::string("HealthCheckInterval"), std::to_string(healthCheckInterval));
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getXForwardedFor_ClientCertClientVerifyAlias() const {
+  return xForwardedFor_ClientCertClientVerifyAlias_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setXForwardedFor_ClientCertClientVerifyAlias(const std::string &xForwardedFor_ClientCertClientVerifyAlias) {
+  xForwardedFor_ClientCertClientVerifyAlias_ = xForwardedFor_ClientCertClientVerifyAlias;
+  setParameter(std::string("XForwardedFor_ClientCertClientVerifyAlias"), xForwardedFor_ClientCertClientVerifyAlias);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getXForwardedFor_SLBID() const {
+  return xForwardedFor_SLBID_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setXForwardedFor_SLBID(const std::string &xForwardedFor_SLBID) {
+  xForwardedFor_SLBID_ = xForwardedFor_SLBID;
+  setParameter(std::string("XForwardedFor_SLBID"), xForwardedFor_SLBID);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getXForwardedFor_ClientCertFingerprint() const {
+  return xForwardedFor_ClientCertFingerprint_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setXForwardedFor_ClientCertFingerprint(const std::string &xForwardedFor_ClientCertFingerprint) {
+  xForwardedFor_ClientCertFingerprint_ = xForwardedFor_ClientCertFingerprint;
+  setParameter(std::string("XForwardedFor_ClientCertFingerprint"), xForwardedFor_ClientCertFingerprint);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getHealthCheckHttpVersion() const {
+  return healthCheckHttpVersion_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckHttpVersion(const std::string &healthCheckHttpVersion) {
+  healthCheckHttpVersion_ = healthCheckHttpVersion;
+  setParameter(std::string("HealthCheckHttpVersion"), healthCheckHttpVersion);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getXForwardedFor_ClientSrcPort() const {
+  return xForwardedFor_ClientSrcPort_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setXForwardedFor_ClientSrcPort(const std::string &xForwardedFor_ClientSrcPort) {
+  xForwardedFor_ClientSrcPort_ = xForwardedFor_ClientSrcPort;
+  setParameter(std::string("XForwardedFor_ClientSrcPort"), xForwardedFor_ClientSrcPort);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getDescription() const {
+  return description_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+int CreateLoadBalancerHTTPSListenerRequest::getUnhealthyThreshold() const {
+  return unhealthyThreshold_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setUnhealthyThreshold(int unhealthyThreshold) {
+  unhealthyThreshold_ = unhealthyThreshold;
+  setParameter(std::string("UnhealthyThreshold"), std::to_string(unhealthyThreshold));
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getXForwardedFor_ClientCertIssuerDNAlias() const {
+  return xForwardedFor_ClientCertIssuerDNAlias_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setXForwardedFor_ClientCertIssuerDNAlias(const std::string &xForwardedFor_ClientCertIssuerDNAlias) {
+  xForwardedFor_ClientCertIssuerDNAlias_ = xForwardedFor_ClientCertIssuerDNAlias;
+  setParameter(std::string("XForwardedFor_ClientCertIssuerDNAlias"), xForwardedFor_ClientCertIssuerDNAlias);
+}
+
+int CreateLoadBalancerHTTPSListenerRequest::getHealthyThreshold() const {
+  return healthyThreshold_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setHealthyThreshold(int healthyThreshold) {
+  healthyThreshold_ = healthyThreshold;
+  setParameter(std::string("HealthyThreshold"), std::to_string(healthyThreshold));
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getScheduler() const {
+  return scheduler_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setScheduler(const std::string &scheduler) {
+  scheduler_ = scheduler;
+  setParameter(std::string("Scheduler"), scheduler);
+}
+
+int CreateLoadBalancerHTTPSListenerRequest::getMaxConnection() const {
+  return maxConnection_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setMaxConnection(int maxConnection) {
+  maxConnection_ = maxConnection;
+  setParameter(std::string("MaxConnection"), std::to_string(maxConnection));
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getEnableHttp2() const {
+  return enableHttp2_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setEnableHttp2(const std::string &enableHttp2) {
+  enableHttp2_ = enableHttp2;
+  setParameter(std::string("EnableHttp2"), enableHttp2);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getXForwardedFor_ClientCertSubjectDN() const {
+  return xForwardedFor_ClientCertSubjectDN_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setXForwardedFor_ClientCertSubjectDN(const std::string &xForwardedFor_ClientCertSubjectDN) {
+  xForwardedFor_ClientCertSubjectDN_ = xForwardedFor_ClientCertSubjectDN;
+  setParameter(std::string("XForwardedFor_ClientCertSubjectDN"), xForwardedFor_ClientCertSubjectDN);
+}
+
+int CreateLoadBalancerHTTPSListenerRequest::getCookieTimeout() const {
+  return cookieTimeout_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setCookieTimeout(int cookieTimeout) {
+  cookieTimeout_ = cookieTimeout;
+  setParameter(std::string("CookieTimeout"), std::to_string(cookieTimeout));
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getStickySessionType() const {
+  return stickySessionType_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setStickySessionType(const std::string &stickySessionType) {
+  stickySessionType_ = stickySessionType;
+  setParameter(std::string("StickySessionType"), stickySessionType);
+}
+
+int CreateLoadBalancerHTTPSListenerRequest::getListenerPort() const {
+  return listenerPort_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setListenerPort(int listenerPort) {
+  listenerPort_ = listenerPort;
+  setParameter(std::string("ListenerPort"), std::to_string(listenerPort));
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getHealthCheckType() const {
+  return healthCheckType_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckType(const std::string &healthCheckType) {
+  healthCheckType_ = healthCheckType;
+  setParameter(std::string("HealthCheckType"), healthCheckType);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+int CreateLoadBalancerHTTPSListenerRequest::getBandwidth() const {
+  return bandwidth_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setBandwidth(int bandwidth) {
+  bandwidth_ = bandwidth;
+  setParameter(std::string("Bandwidth"), std::to_string(bandwidth));
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getStickySession() const {
+  return stickySession_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setStickySession(const std::string &stickySession) {
+  stickySession_ = stickySession;
+  setParameter(std::string("StickySession"), stickySession);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getGzip() const {
+  return gzip_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setGzip(const std::string &gzip) {
+  gzip_ = gzip;
+  setParameter(std::string("Gzip"), gzip);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getTLSCipherPolicy() const {
+  return tLSCipherPolicy_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setTLSCipherPolicy(const std::string &tLSCipherPolicy) {
+  tLSCipherPolicy_ = tLSCipherPolicy;
+  setParameter(std::string("TLSCipherPolicy"), tLSCipherPolicy);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getServerCertificateId() const {
+  return serverCertificateId_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setServerCertificateId(const std::string &serverCertificateId) {
+  serverCertificateId_ = serverCertificateId;
+  setParameter(std::string("ServerCertificateId"), serverCertificateId);
+}
+
+int CreateLoadBalancerHTTPSListenerRequest::getIdleTimeout() const {
+  return idleTimeout_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setIdleTimeout(int idleTimeout) {
+  idleTimeout_ = idleTimeout;
+  setParameter(std::string("IdleTimeout"), std::to_string(idleTimeout));
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getXForwardedFor_proto() const {
+  return xForwardedFor_proto_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setXForwardedFor_proto(const std::string &xForwardedFor_proto) {
+  xForwardedFor_proto_ = xForwardedFor_proto;
+  setParameter(std::string("XForwardedFor_proto"), xForwardedFor_proto);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getXForwardedFor_ClientCertSubjectDNAlias() const {
+  return xForwardedFor_ClientCertSubjectDNAlias_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setXForwardedFor_ClientCertSubjectDNAlias(const std::string &xForwardedFor_ClientCertSubjectDNAlias) {
+  xForwardedFor_ClientCertSubjectDNAlias_ = xForwardedFor_ClientCertSubjectDNAlias;
+  setParameter(std::string("XForwardedFor_ClientCertSubjectDNAlias"), xForwardedFor_ClientCertSubjectDNAlias);
+}
+
+int CreateLoadBalancerHTTPSListenerRequest::getHealthCheckConnectPort() const {
+  return healthCheckConnectPort_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckConnectPort(int healthCheckConnectPort) {
+  healthCheckConnectPort_ = healthCheckConnectPort;
+  setParameter(std::string("HealthCheckConnectPort"), std::to_string(healthCheckConnectPort));
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getHealthCheckHttpCode() const {
+  return healthCheckHttpCode_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckHttpCode(const std::string &healthCheckHttpCode) {
+  healthCheckHttpCode_ = healthCheckHttpCode;
+  setParameter(std::string("HealthCheckHttpCode"), healthCheckHttpCode);
+}
+
+std::string CreateLoadBalancerHTTPSListenerRequest::getXForwardedFor_ClientCertIssuerDN() const {
+  return xForwardedFor_ClientCertIssuerDN_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setXForwardedFor_ClientCertIssuerDN(const std::string &xForwardedFor_ClientCertIssuerDN) {
+  xForwardedFor_ClientCertIssuerDN_ = xForwardedFor_ClientCertIssuerDN;
+  setParameter(std::string("XForwardedFor_ClientCertIssuerDN"), xForwardedFor_ClientCertIssuerDN);
+}
+

slb/src/model/CreateLoadBalancerHTTPSListenerResult.cc

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

slb/src/model/CreateLoadBalancerRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::Slb::Model::CreateLoadBalancerRequest;
 
 CreateLoadBalancerRequest::CreateLoadBalancerRequest()
-    : RpcServiceRequest("slb", "2013-02-21", "CreateLoadBalancer") {
+    : RpcServiceRequest("slb", "2014-05-15", "CreateLoadBalancer") {
   setMethod(HttpRequest::Method::Post);
 }
 
@@ -34,31 +34,31 @@ void CreateLoadBalancerRequest::setResourceOwnerId(long resourceOwnerId) {
   setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-std::string CreateLoadBalancerRequest::getClientToken() const {
-  return clientToken_;
+std::string CreateLoadBalancerRequest::getAddressIPVersion() const {
+  return addressIPVersion_;
 }
 
-void CreateLoadBalancerRequest::setClientToken(const std::string &clientToken) {
-  clientToken_ = clientToken;
-  setParameter(std::string("ClientToken"), clientToken);
+void CreateLoadBalancerRequest::setAddressIPVersion(const std::string &addressIPVersion) {
+  addressIPVersion_ = addressIPVersion;
+  setParameter(std::string("AddressIPVersion"), addressIPVersion);
 }
 
-std::string CreateLoadBalancerRequest::getLoadBalancerMode() const {
-  return loadBalancerMode_;
+std::string CreateLoadBalancerRequest::getMasterZoneId() const {
+  return masterZoneId_;
 }
 
-void CreateLoadBalancerRequest::setLoadBalancerMode(const std::string &loadBalancerMode) {
-  loadBalancerMode_ = loadBalancerMode;
-  setParameter(std::string("LoadBalancerMode"), loadBalancerMode);
+void CreateLoadBalancerRequest::setMasterZoneId(const std::string &masterZoneId) {
+  masterZoneId_ = masterZoneId;
+  setParameter(std::string("MasterZoneId"), masterZoneId);
 }
 
-std::string CreateLoadBalancerRequest::getAccessKeyId() const {
-  return accessKeyId_;
+std::string CreateLoadBalancerRequest::getResourceGroupId() const {
+  return resourceGroupId_;
 }
 
-void CreateLoadBalancerRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
+void CreateLoadBalancerRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
 }
 
 std::string CreateLoadBalancerRequest::getLoadBalancerName() const {
@@ -70,6 +70,164 @@ void CreateLoadBalancerRequest::setLoadBalancerName(const std::string &loadBalan
   setParameter(std::string("LoadBalancerName"), loadBalancerName);
 }
 
+std::string CreateLoadBalancerRequest::getSlaveZoneId() const {
+  return slaveZoneId_;
+}
+
+void CreateLoadBalancerRequest::setSlaveZoneId(const std::string &slaveZoneId) {
+  slaveZoneId_ = slaveZoneId;
+  setParameter(std::string("SlaveZoneId"), slaveZoneId);
+}
+
+std::vector<CreateLoadBalancerRequest::Tag> CreateLoadBalancerRequest::getTag() const {
+  return tag_;
+}
+
+void CreateLoadBalancerRequest::setTag(const std::vector<CreateLoadBalancerRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
+std::string CreateLoadBalancerRequest::getLoadBalancerSpec() const {
+  return loadBalancerSpec_;
+}
+
+void CreateLoadBalancerRequest::setLoadBalancerSpec(const std::string &loadBalancerSpec) {
+  loadBalancerSpec_ = loadBalancerSpec;
+  setParameter(std::string("LoadBalancerSpec"), loadBalancerSpec);
+}
+
+int CreateLoadBalancerRequest::getAutoRenewPeriod() const {
+  return autoRenewPeriod_;
+}
+
+void CreateLoadBalancerRequest::setAutoRenewPeriod(int autoRenewPeriod) {
+  autoRenewPeriod_ = autoRenewPeriod;
+  setParameter(std::string("AutoRenewPeriod"), std::to_string(autoRenewPeriod));
+}
+
+long CreateLoadBalancerRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateLoadBalancerRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateLoadBalancerRequest::getTags() const {
+  return tags_;
+}
+
+void CreateLoadBalancerRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+
+std::string CreateLoadBalancerRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void CreateLoadBalancerRequest::setVSwitchId(const std::string &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  setParameter(std::string("VSwitchId"), vSwitchId);
+}
+
+std::string CreateLoadBalancerRequest::getEnableVpcVipFlow() const {
+  return enableVpcVipFlow_;
+}
+
+void CreateLoadBalancerRequest::setEnableVpcVipFlow(const std::string &enableVpcVipFlow) {
+  enableVpcVipFlow_ = enableVpcVipFlow;
+  setParameter(std::string("EnableVpcVipFlow"), enableVpcVipFlow);
+}
+
+bool CreateLoadBalancerRequest::getAutoRenew() const {
+  return autoRenew_;
+}
+
+void CreateLoadBalancerRequest::setAutoRenew(bool autoRenew) {
+  autoRenew_ = autoRenew;
+  setParameter(std::string("AutoRenew"), autoRenew ? "true" : "false");
+}
+
+std::string CreateLoadBalancerRequest::getInternetChargeType() const {
+  return internetChargeType_;
+}
+
+void CreateLoadBalancerRequest::setInternetChargeType(const std::string &internetChargeType) {
+  internetChargeType_ = internetChargeType;
+  setParameter(std::string("InternetChargeType"), internetChargeType);
+}
+
+std::string CreateLoadBalancerRequest::getPricingCycle() const {
+  return pricingCycle_;
+}
+
+void CreateLoadBalancerRequest::setPricingCycle(const std::string &pricingCycle) {
+  pricingCycle_ = pricingCycle;
+  setParameter(std::string("PricingCycle"), pricingCycle);
+}
+
+std::string CreateLoadBalancerRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void CreateLoadBalancerRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+std::string CreateLoadBalancerRequest::getModificationProtectionReason() const {
+  return modificationProtectionReason_;
+}
+
+void CreateLoadBalancerRequest::setModificationProtectionReason(const std::string &modificationProtectionReason) {
+  modificationProtectionReason_ = modificationProtectionReason;
+  setParameter(std::string("ModificationProtectionReason"), modificationProtectionReason);
+}
+
+bool CreateLoadBalancerRequest::getSupportPrivateLink() const {
+  return supportPrivateLink_;
+}
+
+void CreateLoadBalancerRequest::setSupportPrivateLink(bool supportPrivateLink) {
+  supportPrivateLink_ = supportPrivateLink;
+  setParameter(std::string("SupportPrivateLink"), supportPrivateLink ? "true" : "false");
+}
+
+std::string CreateLoadBalancerRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreateLoadBalancerRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string CreateLoadBalancerRequest::getCloudType() const {
+  return cloudType_;
+}
+
+void CreateLoadBalancerRequest::setCloudType(const std::string &cloudType) {
+  cloudType_ = cloudType;
+  setParameter(std::string("CloudType"), cloudType);
+}
+
+int CreateLoadBalancerRequest::getDuration() const {
+  return duration_;
+}
+
+void CreateLoadBalancerRequest::setDuration(int duration) {
+  duration_ = duration;
+  setParameter(std::string("Duration"), std::to_string(duration));
+}
+
 std::string CreateLoadBalancerRequest::getRegionId() const {
   return regionId_;
 }
@@ -79,6 +237,42 @@ void CreateLoadBalancerRequest::setRegionId(const std::string &regionId) {
   setParameter(std::string("RegionId"), regionId);
 }
 
+std::string CreateLoadBalancerRequest::getAddressType() const {
+  return addressType_;
+}
+
+void CreateLoadBalancerRequest::setAddressType(const std::string &addressType) {
+  addressType_ = addressType;
+  setParameter(std::string("AddressType"), addressType);
+}
+
+std::string CreateLoadBalancerRequest::getInstanceChargeType() const {
+  return instanceChargeType_;
+}
+
+void CreateLoadBalancerRequest::setInstanceChargeType(const std::string &instanceChargeType) {
+  instanceChargeType_ = instanceChargeType;
+  setParameter(std::string("InstanceChargeType"), instanceChargeType);
+}
+
+std::string CreateLoadBalancerRequest::getDeleteProtection() const {
+  return deleteProtection_;
+}
+
+void CreateLoadBalancerRequest::setDeleteProtection(const std::string &deleteProtection) {
+  deleteProtection_ = deleteProtection;
+  setParameter(std::string("DeleteProtection"), deleteProtection);
+}
+
+bool CreateLoadBalancerRequest::getAutoPay() const {
+  return autoPay_;
+}
+
+void CreateLoadBalancerRequest::setAutoPay(bool autoPay) {
+  autoPay_ = autoPay;
+  setParameter(std::string("AutoPay"), autoPay ? "true" : "false");
+}
+
 std::string CreateLoadBalancerRequest::getAddress() const {
   return address_;
 }
@@ -97,6 +291,15 @@ void CreateLoadBalancerRequest::setResourceOwnerAccount(const std::string &resou
   setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
+int CreateLoadBalancerRequest::getBandwidth() const {
+  return bandwidth_;
+}
+
+void CreateLoadBalancerRequest::setBandwidth(int bandwidth) {
+  bandwidth_ = bandwidth;
+  setParameter(std::string("Bandwidth"), std::to_string(bandwidth));
+}
+
 std::string CreateLoadBalancerRequest::getOwnerAccount() const {
   return ownerAccount_;
 }
@@ -106,21 +309,48 @@ void CreateLoadBalancerRequest::setOwnerAccount(const std::string &ownerAccount)
   setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-std::string CreateLoadBalancerRequest::getIsPublicAddress() const {
-  return isPublicAddress_;
+std::string CreateLoadBalancerRequest::getModificationProtectionStatus() const {
+  return modificationProtectionStatus_;
 }
 
-void CreateLoadBalancerRequest::setIsPublicAddress(const std::string &isPublicAddress) {
-  isPublicAddress_ = isPublicAddress;
-  setParameter(std::string("IsPublicAddress"), isPublicAddress);
+void CreateLoadBalancerRequest::setModificationProtectionStatus(const std::string &modificationProtectionStatus) {
+  modificationProtectionStatus_ = modificationProtectionStatus;
+  setParameter(std::string("ModificationProtectionStatus"), modificationProtectionStatus);
 }
 
-long CreateLoadBalancerRequest::getOwnerId() const {
-  return ownerId_;
+std::string CreateLoadBalancerRequest::getInstanceListenerType() const {
+  return instanceListenerType_;
 }
 
-void CreateLoadBalancerRequest::setOwnerId(long ownerId) {
-  ownerId_ = ownerId;
-  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+void CreateLoadBalancerRequest::setInstanceListenerType(const std::string &instanceListenerType) {
+  instanceListenerType_ = instanceListenerType;
+  setParameter(std::string("InstanceListenerType"), instanceListenerType);
+}
+
+std::string CreateLoadBalancerRequest::getVpcId() const {
+  return vpcId_;
+}
+
+void CreateLoadBalancerRequest::setVpcId(const std::string &vpcId) {
+  vpcId_ = vpcId;
+  setParameter(std::string("VpcId"), vpcId);
+}
+
+std::string CreateLoadBalancerRequest::getPayType() const {
+  return payType_;
+}
+
+void CreateLoadBalancerRequest::setPayType(const std::string &payType) {
+  payType_ = payType;
+  setParameter(std::string("PayType"), payType);
+}
+
+int CreateLoadBalancerRequest::getRatio() const {
+  return ratio_;
+}
+
+void CreateLoadBalancerRequest::setRatio(int ratio) {
+  ratio_ = ratio;
+  setParameter(std::string("Ratio"), std::to_string(ratio));
 }
 

slb/src/model/CreateLoadBalancerResult.cc

@@ -39,12 +39,24 @@ void CreateLoadBalancerResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["Address"].isNull())
-		address_ = value["Address"].asString();
+	if(!value["VpcId"].isNull())
+		vpcId_ = value["VpcId"].asString();
+	if(!value["AddressIPVersion"].isNull())
+		addressIPVersion_ = value["AddressIPVersion"].asString();
+	if(!value["VSwitchId"].isNull())
+		vSwitchId_ = value["VSwitchId"].asString();
 	if(!value["LoadBalancerName"].isNull())
 		loadBalancerName_ = value["LoadBalancerName"].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["NetworkType"].isNull())
+		networkType_ = value["NetworkType"].asString();
+	if(!value["OrderId"].isNull())
+		orderId_ = std::stol(value["OrderId"].asString());
 
 }
 
@@ -53,13 +65,43 @@ std::string CreateLoadBalancerResult::getLoadBalancerName()const
 	return loadBalancerName_;
 }
 
+std::string CreateLoadBalancerResult::getVpcId()const
+{
+	return vpcId_;
+}
+
+std::string CreateLoadBalancerResult::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
 std::string CreateLoadBalancerResult::getAddress()const
 {
 	return address_;
 }
 
+std::string CreateLoadBalancerResult::getNetworkType()const
+{
+	return networkType_;
+}
+
+std::string CreateLoadBalancerResult::getAddressIPVersion()const
+{
+	return addressIPVersion_;
+}
+
+std::string CreateLoadBalancerResult::getVSwitchId()const
+{
+	return vSwitchId_;
+}
+
 std::string CreateLoadBalancerResult::getLoadBalancerId()const
 {
 	return loadBalancerId_;
 }
 
+long CreateLoadBalancerResult::getOrderId()const
+{
+	return orderId_;
+}
+

slb/src/model/CreateLoadBalancerTCPListenerRequest.cc

@@ -19,21 +19,12 @@
 using AlibabaCloud::Slb::Model::CreateLoadBalancerTCPListenerRequest;
 
 CreateLoadBalancerTCPListenerRequest::CreateLoadBalancerTCPListenerRequest()
-    : RpcServiceRequest("slb", "2013-02-21", "CreateLoadBalancerTCPListener") {
+    : RpcServiceRequest("slb", "2014-05-15", "CreateLoadBalancerTCPListener") {
   setMethod(HttpRequest::Method::Post);
 }
 
 CreateLoadBalancerTCPListenerRequest::~CreateLoadBalancerTCPListenerRequest() {}
 
-std::string CreateLoadBalancerTCPListenerRequest::getAccess_key_id() const {
-  return access_key_id_;
-}
-
-void CreateLoadBalancerTCPListenerRequest::setAccess_key_id(const std::string &access_key_id) {
-  access_key_id_ = access_key_id;
-  setParameter(std::string("access_key_id"), access_key_id);
-}
-
 long CreateLoadBalancerTCPListenerRequest::getResourceOwnerId() const {
   return resourceOwnerId_;
 }
@@ -52,49 +43,40 @@ void CreateLoadBalancerTCPListenerRequest::setHealthCheckURI(const std::string &
   setParameter(std::string("HealthCheckURI"), healthCheckURI);
 }
 
-int CreateLoadBalancerTCPListenerRequest::getUnhealthyThreshold() const {
-  return unhealthyThreshold_;
+std::string CreateLoadBalancerTCPListenerRequest::getAclStatus() const {
+  return aclStatus_;
 }
 
-void CreateLoadBalancerTCPListenerRequest::setUnhealthyThreshold(int unhealthyThreshold) {
-  unhealthyThreshold_ = unhealthyThreshold;
-  setParameter(std::string("UnhealthyThreshold"), std::to_string(unhealthyThreshold));
+void CreateLoadBalancerTCPListenerRequest::setAclStatus(const std::string &aclStatus) {
+  aclStatus_ = aclStatus;
+  setParameter(std::string("AclStatus"), aclStatus);
 }
 
-int CreateLoadBalancerTCPListenerRequest::getHealthyThreshold() const {
-  return healthyThreshold_;
+bool CreateLoadBalancerTCPListenerRequest::getFullNatEnabled() const {
+  return fullNatEnabled_;
 }
 
-void CreateLoadBalancerTCPListenerRequest::setHealthyThreshold(int healthyThreshold) {
-  healthyThreshold_ = healthyThreshold;
-  setParameter(std::string("HealthyThreshold"), std::to_string(healthyThreshold));
+void CreateLoadBalancerTCPListenerRequest::setFullNatEnabled(bool fullNatEnabled) {
+  fullNatEnabled_ = fullNatEnabled;
+  setParameter(std::string("FullNatEnabled"), fullNatEnabled ? "true" : "false");
 }
 
-std::string CreateLoadBalancerTCPListenerRequest::getAccessKeyId() const {
-  return accessKeyId_;
+bool CreateLoadBalancerTCPListenerRequest::getHealthCheckTcpFastCloseEnabled() const {
+  return healthCheckTcpFastCloseEnabled_;
 }
 
-void CreateLoadBalancerTCPListenerRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
+void CreateLoadBalancerTCPListenerRequest::setHealthCheckTcpFastCloseEnabled(bool healthCheckTcpFastCloseEnabled) {
+  healthCheckTcpFastCloseEnabled_ = healthCheckTcpFastCloseEnabled;
+  setParameter(std::string("HealthCheckTcpFastCloseEnabled"), healthCheckTcpFastCloseEnabled ? "true" : "false");
 }
 
-std::string CreateLoadBalancerTCPListenerRequest::getScheduler() const {
-  return scheduler_;
+std::string CreateLoadBalancerTCPListenerRequest::getAclType() const {
+  return aclType_;
 }
 
-void CreateLoadBalancerTCPListenerRequest::setScheduler(const std::string &scheduler) {
-  scheduler_ = scheduler;
-  setParameter(std::string("Scheduler"), scheduler);
-}
-
-std::string CreateLoadBalancerTCPListenerRequest::getHealthCheck() const {
-  return healthCheck_;
-}
-
-void CreateLoadBalancerTCPListenerRequest::setHealthCheck(const std::string &healthCheck) {
-  healthCheck_ = healthCheck;
-  setParameter(std::string("HealthCheck"), healthCheck);
+void CreateLoadBalancerTCPListenerRequest::setAclType(const std::string &aclType) {
+  aclType_ = aclType;
+  setParameter(std::string("AclType"), aclType);
 }
 
 int CreateLoadBalancerTCPListenerRequest::getEstablishedTimeout() const {
@@ -106,13 +88,13 @@ void CreateLoadBalancerTCPListenerRequest::setEstablishedTimeout(int established
   setParameter(std::string("EstablishedTimeout"), std::to_string(establishedTimeout));
 }
 
-int CreateLoadBalancerTCPListenerRequest::getMaxConnection() const {
-  return maxConnection_;
+std::string CreateLoadBalancerTCPListenerRequest::getFailoverStrategy() const {
+  return failoverStrategy_;
 }
 
-void CreateLoadBalancerTCPListenerRequest::setMaxConnection(int maxConnection) {
-  maxConnection_ = maxConnection;
-  setParameter(std::string("MaxConnection"), std::to_string(maxConnection));
+void CreateLoadBalancerTCPListenerRequest::setFailoverStrategy(const std::string &failoverStrategy) {
+  failoverStrategy_ = failoverStrategy;
+  setParameter(std::string("FailoverStrategy"), failoverStrategy);
 }
 
 int CreateLoadBalancerTCPListenerRequest::getPersistenceTimeout() const {
@@ -124,6 +106,38 @@ void CreateLoadBalancerTCPListenerRequest::setPersistenceTimeout(int persistence
   setParameter(std::string("PersistenceTimeout"), std::to_string(persistenceTimeout));
 }
 
+std::string CreateLoadBalancerTCPListenerRequest::getVpcIds() const {
+  return vpcIds_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setVpcIds(const std::string &vpcIds) {
+  vpcIds_ = vpcIds;
+  setParameter(std::string("VpcIds"), vpcIds);
+}
+
+std::vector<CreateLoadBalancerTCPListenerRequest::Tag> CreateLoadBalancerTCPListenerRequest::getTag() const {
+  return tag_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setTag(const std::vector<CreateLoadBalancerTCPListenerRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
+bool CreateLoadBalancerTCPListenerRequest::getMasterSlaveModeEnabled() const {
+  return masterSlaveModeEnabled_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setMasterSlaveModeEnabled(bool masterSlaveModeEnabled) {
+  masterSlaveModeEnabled_ = masterSlaveModeEnabled;
+  setParameter(std::string("MasterSlaveModeEnabled"), masterSlaveModeEnabled ? "true" : "false");
+}
+
 std::string CreateLoadBalancerTCPListenerRequest::getVServerGroupId() const {
   return vServerGroupId_;
 }
@@ -133,58 +147,36 @@ void CreateLoadBalancerTCPListenerRequest::setVServerGroupId(const std::string &
   setParameter(std::string("VServerGroupId"), vServerGroupId);
 }
 
-int CreateLoadBalancerTCPListenerRequest::getConnectTimeout() const {
-  return connectTimeout_;
+std::string CreateLoadBalancerTCPListenerRequest::getAclId() const {
+  return aclId_;
 }
 
-void CreateLoadBalancerTCPListenerRequest::setConnectTimeout(int connectTimeout) {
-  connectTimeout_ = connectTimeout;
-  setParameter(std::string("ConnectTimeout"), std::to_string(connectTimeout));
+void CreateLoadBalancerTCPListenerRequest::setAclId(const std::string &aclId) {
+  aclId_ = aclId;
+  setParameter(std::string("AclId"), aclId);
 }
 
-int CreateLoadBalancerTCPListenerRequest::getListenerPort() const {
-  return listenerPort_;
+std::vector<CreateLoadBalancerTCPListenerRequest::PortRange> CreateLoadBalancerTCPListenerRequest::getPortRange() const {
+  return portRange_;
 }
 
-void CreateLoadBalancerTCPListenerRequest::setListenerPort(int listenerPort) {
-  listenerPort_ = listenerPort;
-  setParameter(std::string("ListenerPort"), std::to_string(listenerPort));
+void CreateLoadBalancerTCPListenerRequest::setPortRange(const std::vector<CreateLoadBalancerTCPListenerRequest::PortRange> &portRange) {
+  portRange_ = portRange;
+  for(int dep1 = 0; dep1 != portRange.size(); dep1++) {
+  auto portRangeObj = portRange.at(dep1);
+  std::string portRangeObjStr = std::string("PortRange") + "." + std::to_string(dep1 + 1);
+    setParameter(portRangeObjStr + ".StartPort", std::to_string(portRangeObj.startPort));
+    setParameter(portRangeObjStr + ".EndPort", std::to_string(portRangeObj.endPort));
+  }
 }
 
-std::string CreateLoadBalancerTCPListenerRequest::getHealthCheckType() const {
-  return healthCheckType_;
+std::string CreateLoadBalancerTCPListenerRequest::getHealthCheckMethod() const {
+  return healthCheckMethod_;
 }
 
-void CreateLoadBalancerTCPListenerRequest::setHealthCheckType(const std::string &healthCheckType) {
-  healthCheckType_ = healthCheckType;
-  setParameter(std::string("HealthCheckType"), healthCheckType);
-}
-
-std::string CreateLoadBalancerTCPListenerRequest::getResourceOwnerAccount() const {
-  return resourceOwnerAccount_;
-}
-
-void CreateLoadBalancerTCPListenerRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
-  resourceOwnerAccount_ = resourceOwnerAccount;
-  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
-}
-
-int CreateLoadBalancerTCPListenerRequest::getBandwidth() const {
-  return bandwidth_;
-}
-
-void CreateLoadBalancerTCPListenerRequest::setBandwidth(int bandwidth) {
-  bandwidth_ = bandwidth;
-  setParameter(std::string("Bandwidth"), std::to_string(bandwidth));
-}
-
-int CreateLoadBalancerTCPListenerRequest::getConnectPort() const {
-  return connectPort_;
-}
-
-void CreateLoadBalancerTCPListenerRequest::setConnectPort(int connectPort) {
-  connectPort_ = connectPort;
-  setParameter(std::string("ConnectPort"), std::to_string(connectPort));
+void CreateLoadBalancerTCPListenerRequest::setHealthCheckMethod(const std::string &healthCheckMethod) {
+  healthCheckMethod_ = healthCheckMethod;
+  setParameter(std::string("HealthCheckMethod"), healthCheckMethod);
 }
 
 std::string CreateLoadBalancerTCPListenerRequest::getHealthCheckDomain() const {
@@ -196,15 +188,6 @@ void CreateLoadBalancerTCPListenerRequest::setHealthCheckDomain(const std::strin
   setParameter(std::string("HealthCheckDomain"), healthCheckDomain);
 }
 
-std::string CreateLoadBalancerTCPListenerRequest::getOwnerAccount() const {
-  return ownerAccount_;
-}
-
-void CreateLoadBalancerTCPListenerRequest::setOwnerAccount(const std::string &ownerAccount) {
-  ownerAccount_ = ownerAccount;
-  setParameter(std::string("OwnerAccount"), ownerAccount);
-}
-
 long CreateLoadBalancerTCPListenerRequest::getOwnerId() const {
   return ownerId_;
 }
@@ -214,15 +197,6 @@ void CreateLoadBalancerTCPListenerRequest::setOwnerId(long ownerId) {
   setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-std::string CreateLoadBalancerTCPListenerRequest::getListenerStatus() const {
-  return listenerStatus_;
-}
-
-void CreateLoadBalancerTCPListenerRequest::setListenerStatus(const std::string &listenerStatus) {
-  listenerStatus_ = listenerStatus;
-  setParameter(std::string("ListenerStatus"), listenerStatus);
-}
-
 std::string CreateLoadBalancerTCPListenerRequest::getTags() const {
   return tags_;
 }
@@ -259,13 +233,202 @@ void CreateLoadBalancerTCPListenerRequest::setBackendServerPort(int backendServe
   setParameter(std::string("BackendServerPort"), std::to_string(backendServerPort));
 }
 
-int CreateLoadBalancerTCPListenerRequest::getInterval() const {
-  return interval_;
+int CreateLoadBalancerTCPListenerRequest::getHealthCheckInterval() const {
+  return healthCheckInterval_;
 }
 
-void CreateLoadBalancerTCPListenerRequest::setInterval(int interval) {
-  interval_ = interval;
-  setParameter(std::string("Interval"), std::to_string(interval));
+void CreateLoadBalancerTCPListenerRequest::setHealthCheckInterval(int healthCheckInterval) {
+  healthCheckInterval_ = healthCheckInterval;
+  setParameter(std::string("healthCheckInterval"), std::to_string(healthCheckInterval));
+}
+
+int CreateLoadBalancerTCPListenerRequest::getFailoverThreshold() const {
+  return failoverThreshold_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setFailoverThreshold(int failoverThreshold) {
+  failoverThreshold_ = failoverThreshold;
+  setParameter(std::string("FailoverThreshold"), std::to_string(failoverThreshold));
+}
+
+bool CreateLoadBalancerTCPListenerRequest::getProxyProtocolV2Enabled() const {
+  return proxyProtocolV2Enabled_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setProxyProtocolV2Enabled(bool proxyProtocolV2Enabled) {
+  proxyProtocolV2Enabled_ = proxyProtocolV2Enabled;
+  setParameter(std::string("ProxyProtocolV2Enabled"), proxyProtocolV2Enabled ? "true" : "false");
+}
+
+std::string CreateLoadBalancerTCPListenerRequest::getConnectionDrain() const {
+  return connectionDrain_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setConnectionDrain(const std::string &connectionDrain) {
+  connectionDrain_ = connectionDrain;
+  setParameter(std::string("ConnectionDrain"), connectionDrain);
+}
+
+std::string CreateLoadBalancerTCPListenerRequest::getHealthCheckSwitch() const {
+  return healthCheckSwitch_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setHealthCheckSwitch(const std::string &healthCheckSwitch) {
+  healthCheckSwitch_ = healthCheckSwitch;
+  setParameter(std::string("HealthCheckSwitch"), healthCheckSwitch);
+}
+
+std::string CreateLoadBalancerTCPListenerRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+int CreateLoadBalancerTCPListenerRequest::getHealthCheckConnectTimeout() const {
+  return healthCheckConnectTimeout_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setHealthCheckConnectTimeout(int healthCheckConnectTimeout) {
+  healthCheckConnectTimeout_ = healthCheckConnectTimeout;
+  setParameter(std::string("HealthCheckConnectTimeout"), std::to_string(healthCheckConnectTimeout));
+}
+
+std::string CreateLoadBalancerTCPListenerRequest::getSlaveServerGroupId() const {
+  return slaveServerGroupId_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setSlaveServerGroupId(const std::string &slaveServerGroupId) {
+  slaveServerGroupId_ = slaveServerGroupId;
+  setParameter(std::string("SlaveServerGroupId"), slaveServerGroupId);
+}
+
+std::string CreateLoadBalancerTCPListenerRequest::getDescription() const {
+  return description_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+int CreateLoadBalancerTCPListenerRequest::getUnhealthyThreshold() const {
+  return unhealthyThreshold_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setUnhealthyThreshold(int unhealthyThreshold) {
+  unhealthyThreshold_ = unhealthyThreshold;
+  setParameter(std::string("UnhealthyThreshold"), std::to_string(unhealthyThreshold));
+}
+
+int CreateLoadBalancerTCPListenerRequest::getHealthyThreshold() const {
+  return healthyThreshold_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setHealthyThreshold(int healthyThreshold) {
+  healthyThreshold_ = healthyThreshold;
+  setParameter(std::string("HealthyThreshold"), std::to_string(healthyThreshold));
+}
+
+std::string CreateLoadBalancerTCPListenerRequest::getScheduler() const {
+  return scheduler_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setScheduler(const std::string &scheduler) {
+  scheduler_ = scheduler;
+  setParameter(std::string("Scheduler"), scheduler);
+}
+
+int CreateLoadBalancerTCPListenerRequest::getMaxConnection() const {
+  return maxConnection_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setMaxConnection(int maxConnection) {
+  maxConnection_ = maxConnection;
+  setParameter(std::string("MaxConnection"), std::to_string(maxConnection));
+}
+
+std::string CreateLoadBalancerTCPListenerRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateLoadBalancerTCPListenerRequest::getMasterServerGroupId() const {
+  return masterServerGroupId_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setMasterServerGroupId(const std::string &masterServerGroupId) {
+  masterServerGroupId_ = masterServerGroupId;
+  setParameter(std::string("MasterServerGroupId"), masterServerGroupId);
+}
+
+int CreateLoadBalancerTCPListenerRequest::getListenerPort() const {
+  return listenerPort_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setListenerPort(int listenerPort) {
+  listenerPort_ = listenerPort;
+  setParameter(std::string("ListenerPort"), std::to_string(listenerPort));
+}
+
+std::string CreateLoadBalancerTCPListenerRequest::getHealthCheckType() const {
+  return healthCheckType_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setHealthCheckType(const std::string &healthCheckType) {
+  healthCheckType_ = healthCheckType;
+  setParameter(std::string("HealthCheckType"), healthCheckType);
+}
+
+std::string CreateLoadBalancerTCPListenerRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+int CreateLoadBalancerTCPListenerRequest::getBandwidth() const {
+  return bandwidth_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setBandwidth(int bandwidth) {
+  bandwidth_ = bandwidth;
+  setParameter(std::string("Bandwidth"), std::to_string(bandwidth));
+}
+
+std::string CreateLoadBalancerTCPListenerRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+int CreateLoadBalancerTCPListenerRequest::getConnectionDrainTimeout() const {
+  return connectionDrainTimeout_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setConnectionDrainTimeout(int connectionDrainTimeout) {
+  connectionDrainTimeout_ = connectionDrainTimeout;
+  setParameter(std::string("ConnectionDrainTimeout"), std::to_string(connectionDrainTimeout));
+}
+
+int CreateLoadBalancerTCPListenerRequest::getHealthCheckConnectPort() const {
+  return healthCheckConnectPort_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setHealthCheckConnectPort(int healthCheckConnectPort) {
+  healthCheckConnectPort_ = healthCheckConnectPort;
+  setParameter(std::string("HealthCheckConnectPort"), std::to_string(healthCheckConnectPort));
 }
 
 std::string CreateLoadBalancerTCPListenerRequest::getHealthCheckHttpCode() const {

slb/src/model/CreateLoadBalancerUDPListenerRequest.cc

@@ -0,0 +1,451 @@
+/*
+ * 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/CreateLoadBalancerUDPListenerRequest.h>
+
+using AlibabaCloud::Slb::Model::CreateLoadBalancerUDPListenerRequest;
+
+CreateLoadBalancerUDPListenerRequest::CreateLoadBalancerUDPListenerRequest()
+    : RpcServiceRequest("slb", "2014-05-15", "CreateLoadBalancerUDPListener") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateLoadBalancerUDPListenerRequest::~CreateLoadBalancerUDPListenerRequest() {}
+
+long CreateLoadBalancerUDPListenerRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getHealthCheckURI() const {
+  return healthCheckURI_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setHealthCheckURI(const std::string &healthCheckURI) {
+  healthCheckURI_ = healthCheckURI;
+  setParameter(std::string("HealthCheckURI"), healthCheckURI);
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getAclStatus() const {
+  return aclStatus_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setAclStatus(const std::string &aclStatus) {
+  aclStatus_ = aclStatus;
+  setParameter(std::string("AclStatus"), aclStatus);
+}
+
+bool CreateLoadBalancerUDPListenerRequest::getFullNatEnabled() const {
+  return fullNatEnabled_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setFullNatEnabled(bool fullNatEnabled) {
+  fullNatEnabled_ = fullNatEnabled;
+  setParameter(std::string("FullNatEnabled"), fullNatEnabled ? "true" : "false");
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getAclType() const {
+  return aclType_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setAclType(const std::string &aclType) {
+  aclType_ = aclType;
+  setParameter(std::string("AclType"), aclType);
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getFailoverStrategy() const {
+  return failoverStrategy_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setFailoverStrategy(const std::string &failoverStrategy) {
+  failoverStrategy_ = failoverStrategy;
+  setParameter(std::string("FailoverStrategy"), failoverStrategy);
+}
+
+int CreateLoadBalancerUDPListenerRequest::getPersistenceTimeout() const {
+  return persistenceTimeout_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setPersistenceTimeout(int persistenceTimeout) {
+  persistenceTimeout_ = persistenceTimeout;
+  setParameter(std::string("PersistenceTimeout"), std::to_string(persistenceTimeout));
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getVpcIds() const {
+  return vpcIds_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setVpcIds(const std::string &vpcIds) {
+  vpcIds_ = vpcIds;
+  setParameter(std::string("VpcIds"), vpcIds);
+}
+
+std::vector<CreateLoadBalancerUDPListenerRequest::Tag> CreateLoadBalancerUDPListenerRequest::getTag() const {
+  return tag_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setTag(const std::vector<CreateLoadBalancerUDPListenerRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
+bool CreateLoadBalancerUDPListenerRequest::getMasterSlaveModeEnabled() const {
+  return masterSlaveModeEnabled_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setMasterSlaveModeEnabled(bool masterSlaveModeEnabled) {
+  masterSlaveModeEnabled_ = masterSlaveModeEnabled;
+  setParameter(std::string("MasterSlaveModeEnabled"), masterSlaveModeEnabled ? "true" : "false");
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getVServerGroupId() const {
+  return vServerGroupId_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setVServerGroupId(const std::string &vServerGroupId) {
+  vServerGroupId_ = vServerGroupId;
+  setParameter(std::string("VServerGroupId"), vServerGroupId);
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getAclId() const {
+  return aclId_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setAclId(const std::string &aclId) {
+  aclId_ = aclId;
+  setParameter(std::string("AclId"), aclId);
+}
+
+std::vector<CreateLoadBalancerUDPListenerRequest::PortRange> CreateLoadBalancerUDPListenerRequest::getPortRange() const {
+  return portRange_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setPortRange(const std::vector<CreateLoadBalancerUDPListenerRequest::PortRange> &portRange) {
+  portRange_ = portRange;
+  for(int dep1 = 0; dep1 != portRange.size(); dep1++) {
+  auto portRangeObj = portRange.at(dep1);
+  std::string portRangeObjStr = std::string("PortRange") + "." + std::to_string(dep1 + 1);
+    setParameter(portRangeObjStr + ".StartPort", std::to_string(portRangeObj.startPort));
+    setParameter(portRangeObjStr + ".EndPort", std::to_string(portRangeObj.endPort));
+  }
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getHealthCheckMethod() const {
+  return healthCheckMethod_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setHealthCheckMethod(const std::string &healthCheckMethod) {
+  healthCheckMethod_ = healthCheckMethod;
+  setParameter(std::string("HealthCheckMethod"), healthCheckMethod);
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getHealthCheckDomain() const {
+  return healthCheckDomain_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setHealthCheckDomain(const std::string &healthCheckDomain) {
+  healthCheckDomain_ = healthCheckDomain;
+  setParameter(std::string("HealthCheckDomain"), healthCheckDomain);
+}
+
+long CreateLoadBalancerUDPListenerRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getTags() const {
+  return tags_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getLoadBalancerId() const {
+  return loadBalancerId_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setLoadBalancerId(const std::string &loadBalancerId) {
+  loadBalancerId_ = loadBalancerId;
+  setParameter(std::string("LoadBalancerId"), loadBalancerId);
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getMasterSlaveServerGroupId() const {
+  return masterSlaveServerGroupId_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setMasterSlaveServerGroupId(const std::string &masterSlaveServerGroupId) {
+  masterSlaveServerGroupId_ = masterSlaveServerGroupId;
+  setParameter(std::string("MasterSlaveServerGroupId"), masterSlaveServerGroupId);
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getHealthCheckReq() const {
+  return healthCheckReq_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setHealthCheckReq(const std::string &healthCheckReq) {
+  healthCheckReq_ = healthCheckReq;
+  setParameter(std::string("healthCheckReq"), healthCheckReq);
+}
+
+int CreateLoadBalancerUDPListenerRequest::getBackendServerPort() const {
+  return backendServerPort_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setBackendServerPort(int backendServerPort) {
+  backendServerPort_ = backendServerPort;
+  setParameter(std::string("BackendServerPort"), std::to_string(backendServerPort));
+}
+
+int CreateLoadBalancerUDPListenerRequest::getHealthCheckInterval() const {
+  return healthCheckInterval_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setHealthCheckInterval(int healthCheckInterval) {
+  healthCheckInterval_ = healthCheckInterval;
+  setParameter(std::string("healthCheckInterval"), std::to_string(healthCheckInterval));
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getHealthCheckExp() const {
+  return healthCheckExp_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setHealthCheckExp(const std::string &healthCheckExp) {
+  healthCheckExp_ = healthCheckExp;
+  setParameter(std::string("healthCheckExp"), healthCheckExp);
+}
+
+int CreateLoadBalancerUDPListenerRequest::getFailoverThreshold() const {
+  return failoverThreshold_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setFailoverThreshold(int failoverThreshold) {
+  failoverThreshold_ = failoverThreshold;
+  setParameter(std::string("FailoverThreshold"), std::to_string(failoverThreshold));
+}
+
+bool CreateLoadBalancerUDPListenerRequest::getProxyProtocolV2Enabled() const {
+  return proxyProtocolV2Enabled_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setProxyProtocolV2Enabled(bool proxyProtocolV2Enabled) {
+  proxyProtocolV2Enabled_ = proxyProtocolV2Enabled;
+  setParameter(std::string("ProxyProtocolV2Enabled"), proxyProtocolV2Enabled ? "true" : "false");
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getConnectionDrain() const {
+  return connectionDrain_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setConnectionDrain(const std::string &connectionDrain) {
+  connectionDrain_ = connectionDrain;
+  setParameter(std::string("ConnectionDrain"), connectionDrain);
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getHealthCheckSwitch() const {
+  return healthCheckSwitch_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setHealthCheckSwitch(const std::string &healthCheckSwitch) {
+  healthCheckSwitch_ = healthCheckSwitch;
+  setParameter(std::string("HealthCheckSwitch"), healthCheckSwitch);
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+int CreateLoadBalancerUDPListenerRequest::getHealthCheckConnectTimeout() const {
+  return healthCheckConnectTimeout_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setHealthCheckConnectTimeout(int healthCheckConnectTimeout) {
+  healthCheckConnectTimeout_ = healthCheckConnectTimeout;
+  setParameter(std::string("HealthCheckConnectTimeout"), std::to_string(healthCheckConnectTimeout));
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getSlaveServerGroupId() const {
+  return slaveServerGroupId_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setSlaveServerGroupId(const std::string &slaveServerGroupId) {
+  slaveServerGroupId_ = slaveServerGroupId;
+  setParameter(std::string("SlaveServerGroupId"), slaveServerGroupId);
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getQuicVersion() const {
+  return quicVersion_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setQuicVersion(const std::string &quicVersion) {
+  quicVersion_ = quicVersion;
+  setParameter(std::string("QuicVersion"), quicVersion);
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getDescription() const {
+  return description_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+int CreateLoadBalancerUDPListenerRequest::getUnhealthyThreshold() const {
+  return unhealthyThreshold_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setUnhealthyThreshold(int unhealthyThreshold) {
+  unhealthyThreshold_ = unhealthyThreshold;
+  setParameter(std::string("UnhealthyThreshold"), std::to_string(unhealthyThreshold));
+}
+
+int CreateLoadBalancerUDPListenerRequest::getHealthyThreshold() const {
+  return healthyThreshold_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setHealthyThreshold(int healthyThreshold) {
+  healthyThreshold_ = healthyThreshold;
+  setParameter(std::string("HealthyThreshold"), std::to_string(healthyThreshold));
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getScheduler() const {
+  return scheduler_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setScheduler(const std::string &scheduler) {
+  scheduler_ = scheduler;
+  setParameter(std::string("Scheduler"), scheduler);
+}
+
+int CreateLoadBalancerUDPListenerRequest::getMaxConnection() const {
+  return maxConnection_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setMaxConnection(int maxConnection) {
+  maxConnection_ = maxConnection;
+  setParameter(std::string("MaxConnection"), std::to_string(maxConnection));
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getMasterServerGroupId() const {
+  return masterServerGroupId_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setMasterServerGroupId(const std::string &masterServerGroupId) {
+  masterServerGroupId_ = masterServerGroupId;
+  setParameter(std::string("MasterServerGroupId"), masterServerGroupId);
+}
+
+int CreateLoadBalancerUDPListenerRequest::getListenerPort() const {
+  return listenerPort_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setListenerPort(int listenerPort) {
+  listenerPort_ = listenerPort;
+  setParameter(std::string("ListenerPort"), std::to_string(listenerPort));
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getHealthCheckType() const {
+  return healthCheckType_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setHealthCheckType(const std::string &healthCheckType) {
+  healthCheckType_ = healthCheckType;
+  setParameter(std::string("HealthCheckType"), healthCheckType);
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+int CreateLoadBalancerUDPListenerRequest::getBandwidth() const {
+  return bandwidth_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setBandwidth(int bandwidth) {
+  bandwidth_ = bandwidth;
+  setParameter(std::string("Bandwidth"), std::to_string(bandwidth));
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+int CreateLoadBalancerUDPListenerRequest::getConnectionDrainTimeout() const {
+  return connectionDrainTimeout_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setConnectionDrainTimeout(int connectionDrainTimeout) {
+  connectionDrainTimeout_ = connectionDrainTimeout;
+  setParameter(std::string("ConnectionDrainTimeout"), std::to_string(connectionDrainTimeout));
+}
+
+int CreateLoadBalancerUDPListenerRequest::getHealthCheckConnectPort() const {
+  return healthCheckConnectPort_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setHealthCheckConnectPort(int healthCheckConnectPort) {
+  healthCheckConnectPort_ = healthCheckConnectPort;
+  setParameter(std::string("HealthCheckConnectPort"), std::to_string(healthCheckConnectPort));
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getHealthCheckHttpCode() const {
+  return healthCheckHttpCode_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setHealthCheckHttpCode(const std::string &healthCheckHttpCode) {
+  healthCheckHttpCode_ = healthCheckHttpCode;
+  setParameter(std::string("HealthCheckHttpCode"), healthCheckHttpCode);
+}
+

slb/src/model/CreateLoadBalancerUDPListenerResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/slb/model/SetLoadBalancerListenerStatusResult.h>
+#include <alibabacloud/slb/model/CreateLoadBalancerUDPListenerResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Slb;
 using namespace AlibabaCloud::Slb::Model;
 
-SetLoadBalancerListenerStatusResult::SetLoadBalancerListenerStatusResult() :
+CreateLoadBalancerUDPListenerResult::CreateLoadBalancerUDPListenerResult() :
 	ServiceResult()
 {}
 
-SetLoadBalancerListenerStatusResult::SetLoadBalancerListenerStatusResult(const std::string &payload) :
+CreateLoadBalancerUDPListenerResult::CreateLoadBalancerUDPListenerResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-SetLoadBalancerListenerStatusResult::~SetLoadBalancerListenerStatusResult()
+CreateLoadBalancerUDPListenerResult::~CreateLoadBalancerUDPListenerResult()
 {}
 
-void SetLoadBalancerListenerStatusResult::parse(const std::string &payload)
+void CreateLoadBalancerUDPListenerResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;

slb/src/model/CreateMasterSlaveServerGroupRequest.cc

@@ -0,0 +1,131 @@
+/*
+ * 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/CreateMasterSlaveServerGroupRequest.h>
+
+using AlibabaCloud::Slb::Model::CreateMasterSlaveServerGroupRequest;
+
+CreateMasterSlaveServerGroupRequest::CreateMasterSlaveServerGroupRequest()
+    : RpcServiceRequest("slb", "2014-05-15", "CreateMasterSlaveServerGroup") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateMasterSlaveServerGroupRequest::~CreateMasterSlaveServerGroupRequest() {}
+
+std::string CreateMasterSlaveServerGroupRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void CreateMasterSlaveServerGroupRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+long CreateMasterSlaveServerGroupRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateMasterSlaveServerGroupRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreateMasterSlaveServerGroupRequest::getMasterSlaveBackendServers() const {
+  return masterSlaveBackendServers_;
+}
+
+void CreateMasterSlaveServerGroupRequest::setMasterSlaveBackendServers(const std::string &masterSlaveBackendServers) {
+  masterSlaveBackendServers_ = masterSlaveBackendServers;
+  setParameter(std::string("MasterSlaveBackendServers"), masterSlaveBackendServers);
+}
+
+std::string CreateMasterSlaveServerGroupRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateMasterSlaveServerGroupRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::vector<CreateMasterSlaveServerGroupRequest::Tag> CreateMasterSlaveServerGroupRequest::getTag() const {
+  return tag_;
+}
+
+void CreateMasterSlaveServerGroupRequest::setTag(const std::vector<CreateMasterSlaveServerGroupRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
+std::string CreateMasterSlaveServerGroupRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreateMasterSlaveServerGroupRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CreateMasterSlaveServerGroupRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreateMasterSlaveServerGroupRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::string CreateMasterSlaveServerGroupRequest::getMasterSlaveServerGroupName() const {
+  return masterSlaveServerGroupName_;
+}
+
+void CreateMasterSlaveServerGroupRequest::setMasterSlaveServerGroupName(const std::string &masterSlaveServerGroupName) {
+  masterSlaveServerGroupName_ = masterSlaveServerGroupName;
+  setParameter(std::string("MasterSlaveServerGroupName"), masterSlaveServerGroupName);
+}
+
+long CreateMasterSlaveServerGroupRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateMasterSlaveServerGroupRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateMasterSlaveServerGroupRequest::getTags() const {
+  return tags_;
+}
+
+void CreateMasterSlaveServerGroupRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+
+std::string CreateMasterSlaveServerGroupRequest::getLoadBalancerId() const {
+  return loadBalancerId_;
+}
+
+void CreateMasterSlaveServerGroupRequest::setLoadBalancerId(const std::string &loadBalancerId) {
+  loadBalancerId_ = loadBalancerId;
+  setParameter(std::string("LoadBalancerId"), loadBalancerId);
+}
+

slb/src/model/CreateMasterSlaveServerGroupResult.cc

@@ -0,0 +1,78 @@
+/*
+ * 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/CreateMasterSlaveServerGroupResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+CreateMasterSlaveServerGroupResult::CreateMasterSlaveServerGroupResult() :
+	ServiceResult()
+{}
+
+CreateMasterSlaveServerGroupResult::CreateMasterSlaveServerGroupResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateMasterSlaveServerGroupResult::~CreateMasterSlaveServerGroupResult()
+{}
+
+void CreateMasterSlaveServerGroupResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allMasterSlaveBackendServersNode = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
+	for (auto valueMasterSlaveBackendServersMasterSlaveBackendServer : allMasterSlaveBackendServersNode)
+	{
+		MasterSlaveBackendServer masterSlaveBackendServersObject;
+		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["VpcId"].isNull())
+			masterSlaveBackendServersObject.vpcId = valueMasterSlaveBackendServersMasterSlaveBackendServer["VpcId"].asString();
+		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Type"].isNull())
+			masterSlaveBackendServersObject.type = valueMasterSlaveBackendServersMasterSlaveBackendServer["Type"].asString();
+		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Weight"].isNull())
+			masterSlaveBackendServersObject.weight = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["Weight"].asString());
+		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Description"].isNull())
+			masterSlaveBackendServersObject.description = valueMasterSlaveBackendServersMasterSlaveBackendServer["Description"].asString();
+		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerIp"].isNull())
+			masterSlaveBackendServersObject.serverIp = valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerIp"].asString();
+		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Port"].isNull())
+			masterSlaveBackendServersObject.port = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["Port"].asString());
+		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerId"].isNull())
+			masterSlaveBackendServersObject.serverId = valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerId"].asString();
+		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerType"].isNull())
+			masterSlaveBackendServersObject.serverType = valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerType"].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_;
+}
+

slb/src/model/CreateRulesRequest.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/CreateRulesRequest.h>
+
+using AlibabaCloud::Slb::Model::CreateRulesRequest;
+
+CreateRulesRequest::CreateRulesRequest()
+    : RpcServiceRequest("slb", "2014-05-15", "CreateRules") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateRulesRequest::~CreateRulesRequest() {}
+
+std::string CreateRulesRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void CreateRulesRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+long CreateRulesRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateRulesRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreateRulesRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateRulesRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateRulesRequest::getRuleList() const {
+  return ruleList_;
+}
+
+void CreateRulesRequest::setRuleList(const std::string &ruleList) {
+  ruleList_ = ruleList;
+  setParameter(std::string("RuleList"), ruleList);
+}
+
+int CreateRulesRequest::getListenerPort() const {
+  return listenerPort_;
+}
+
+void CreateRulesRequest::setListenerPort(int listenerPort) {
+  listenerPort_ = listenerPort;
+  setParameter(std::string("ListenerPort"), std::to_string(listenerPort));
+}
+
+std::string CreateRulesRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreateRulesRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CreateRulesRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreateRulesRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long CreateRulesRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateRulesRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateRulesRequest::getListenerProtocol() const {
+  return listenerProtocol_;
+}
+
+void CreateRulesRequest::setListenerProtocol(const std::string &listenerProtocol) {
+  listenerProtocol_ = listenerProtocol;
+  setParameter(std::string("ListenerProtocol"), listenerProtocol);
+}
+
+std::string CreateRulesRequest::getTags() const {
+  return tags_;
+}
+
+void CreateRulesRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+
+std::string CreateRulesRequest::getLoadBalancerId() const {
+  return loadBalancerId_;
+}
+
+void CreateRulesRequest::setLoadBalancerId(const std::string &loadBalancerId) {
+  loadBalancerId_ = loadBalancerId;
+  setParameter(std::string("LoadBalancerId"), loadBalancerId);
+}
+

slb/src/model/CreateRulesResult.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/CreateRulesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+CreateRulesResult::CreateRulesResult() :
+	ServiceResult()
+{}
+
+CreateRulesResult::CreateRulesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateRulesResult::~CreateRulesResult()
+{}
+
+void CreateRulesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allRulesNode = value["Rules"]["Rule"];
+	for (auto valueRulesRule : allRulesNode)
+	{
+		Rule rulesObject;
+		if(!valueRulesRule["RuleName"].isNull())
+			rulesObject.ruleName = valueRulesRule["RuleName"].asString();
+		if(!valueRulesRule["RuleId"].isNull())
+			rulesObject.ruleId = valueRulesRule["RuleId"].asString();
+		rules_.push_back(rulesObject);
+	}
+
+}
+
+std::vector<CreateRulesResult::Rule> CreateRulesResult::getRules()const
+{
+	return rules_;
+}
+

slb/src/model/CreateTLSCipherPolicyRequest.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/CreateTLSCipherPolicyRequest.h>
+
+using AlibabaCloud::Slb::Model::CreateTLSCipherPolicyRequest;
+
+CreateTLSCipherPolicyRequest::CreateTLSCipherPolicyRequest()
+    : RpcServiceRequest("slb", "2014-05-15", "CreateTLSCipherPolicy") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateTLSCipherPolicyRequest::~CreateTLSCipherPolicyRequest() {}
+
+std::string CreateTLSCipherPolicyRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void CreateTLSCipherPolicyRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+long CreateTLSCipherPolicyRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateTLSCipherPolicyRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreateTLSCipherPolicyRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void CreateTLSCipherPolicyRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string CreateTLSCipherPolicyRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateTLSCipherPolicyRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::vector<std::string> CreateTLSCipherPolicyRequest::getCiphers() const {
+  return ciphers_;
+}
+
+void CreateTLSCipherPolicyRequest::setCiphers(const std::vector<std::string> &ciphers) {
+  ciphers_ = ciphers;
+}
+
+std::vector<std::string> CreateTLSCipherPolicyRequest::getTLSVersions() const {
+  return tLSVersions_;
+}
+
+void CreateTLSCipherPolicyRequest::setTLSVersions(const std::vector<std::string> &tLSVersions) {
+  tLSVersions_ = tLSVersions;
+}
+
+std::string CreateTLSCipherPolicyRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreateTLSCipherPolicyRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CreateTLSCipherPolicyRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreateTLSCipherPolicyRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long CreateTLSCipherPolicyRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateTLSCipherPolicyRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateTLSCipherPolicyRequest::getName() const {
+  return name_;
+}
+
+void CreateTLSCipherPolicyRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+

slb/src/model/CreateTLSCipherPolicyResult.cc

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

slb/src/model/CreateVServerGroupRequest.cc

@@ -0,0 +1,131 @@
+/*
+ * 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/CreateVServerGroupRequest.h>
+
+using AlibabaCloud::Slb::Model::CreateVServerGroupRequest;
+
+CreateVServerGroupRequest::CreateVServerGroupRequest()
+    : RpcServiceRequest("slb", "2014-05-15", "CreateVServerGroup") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateVServerGroupRequest::~CreateVServerGroupRequest() {}
+
+std::string CreateVServerGroupRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void CreateVServerGroupRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+long CreateVServerGroupRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateVServerGroupRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreateVServerGroupRequest::getBackendServers() const {
+  return backendServers_;
+}
+
+void CreateVServerGroupRequest::setBackendServers(const std::string &backendServers) {
+  backendServers_ = backendServers;
+  setParameter(std::string("BackendServers"), backendServers);
+}
+
+std::string CreateVServerGroupRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateVServerGroupRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::vector<CreateVServerGroupRequest::Tag> CreateVServerGroupRequest::getTag() const {
+  return tag_;
+}
+
+void CreateVServerGroupRequest::setTag(const std::vector<CreateVServerGroupRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
+std::string CreateVServerGroupRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreateVServerGroupRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CreateVServerGroupRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreateVServerGroupRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long CreateVServerGroupRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateVServerGroupRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateVServerGroupRequest::getTags() const {
+  return tags_;
+}
+
+void CreateVServerGroupRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+
+std::string CreateVServerGroupRequest::getVServerGroupName() const {
+  return vServerGroupName_;
+}
+
+void CreateVServerGroupRequest::setVServerGroupName(const std::string &vServerGroupName) {
+  vServerGroupName_ = vServerGroupName;
+  setParameter(std::string("VServerGroupName"), vServerGroupName);
+}
+
+std::string CreateVServerGroupRequest::getLoadBalancerId() const {
+  return loadBalancerId_;
+}
+
+void CreateVServerGroupRequest::setLoadBalancerId(const std::string &loadBalancerId) {
+  loadBalancerId_ = loadBalancerId;
+  setParameter(std::string("LoadBalancerId"), loadBalancerId);
+}
+

slb/src/model/CreateVServerGroupResult.cc

@@ -0,0 +1,80 @@
+/*
+ * 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/CreateVServerGroupResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+CreateVServerGroupResult::CreateVServerGroupResult() :
+	ServiceResult()
+{}
+
+CreateVServerGroupResult::CreateVServerGroupResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateVServerGroupResult::~CreateVServerGroupResult()
+{}
+
+void CreateVServerGroupResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allBackendServersNode = value["BackendServers"]["BackendServer"];
+	for (auto valueBackendServersBackendServer : allBackendServersNode)
+	{
+		BackendServer backendServersObject;
+		if(!valueBackendServersBackendServer["VpcId"].isNull())
+			backendServersObject.vpcId = valueBackendServersBackendServer["VpcId"].asString();
+		if(!valueBackendServersBackendServer["Type"].isNull())
+			backendServersObject.type = valueBackendServersBackendServer["Type"].asString();
+		if(!valueBackendServersBackendServer["Weight"].isNull())
+			backendServersObject.weight = std::stoi(valueBackendServersBackendServer["Weight"].asString());
+		if(!valueBackendServersBackendServer["Description"].isNull())
+			backendServersObject.description = valueBackendServersBackendServer["Description"].asString();
+		if(!valueBackendServersBackendServer["ServerRegionId"].isNull())
+			backendServersObject.serverRegionId = valueBackendServersBackendServer["ServerRegionId"].asString();
+		if(!valueBackendServersBackendServer["ServerIp"].isNull())
+			backendServersObject.serverIp = valueBackendServersBackendServer["ServerIp"].asString();
+		if(!valueBackendServersBackendServer["Port"].isNull())
+			backendServersObject.port = std::stoi(valueBackendServersBackendServer["Port"].asString());
+		if(!valueBackendServersBackendServer["VbrId"].isNull())
+			backendServersObject.vbrId = valueBackendServersBackendServer["VbrId"].asString();
+		if(!valueBackendServersBackendServer["ServerId"].isNull())
+			backendServersObject.serverId = valueBackendServersBackendServer["ServerId"].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_;
+}
+

slb/src/model/DeleteAccessControlListRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * 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") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+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(std::string("access_key_id"), access_key_id);
+}
+
+long DeleteAccessControlListRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DeleteAccessControlListRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DeleteAccessControlListRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DeleteAccessControlListRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string DeleteAccessControlListRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DeleteAccessControlListRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DeleteAccessControlListRequest::getAclId() const {
+  return aclId_;
+}
+
+void DeleteAccessControlListRequest::setAclId(const std::string &aclId) {
+  aclId_ = aclId;
+  setParameter(std::string("AclId"), aclId);
+}
+
+std::string DeleteAccessControlListRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DeleteAccessControlListRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DeleteAccessControlListRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DeleteAccessControlListRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DeleteAccessControlListRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DeleteAccessControlListRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DeleteAccessControlListRequest::getTags() const {
+  return tags_;
+}
+
+void DeleteAccessControlListRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+

slb/src/model/DeleteAccessControlListResult.cc

@@ -0,0 +1,44 @@
+/*
+ * 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/DeleteAccessLogsDownloadAttributeRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * 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/DeleteAccessLogsDownloadAttributeRequest.h>
+
+using AlibabaCloud::Slb::Model::DeleteAccessLogsDownloadAttributeRequest;
+
+DeleteAccessLogsDownloadAttributeRequest::DeleteAccessLogsDownloadAttributeRequest()
+    : RpcServiceRequest("slb", "2014-05-15", "DeleteAccessLogsDownloadAttribute") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteAccessLogsDownloadAttributeRequest::~DeleteAccessLogsDownloadAttributeRequest() {}
+
+std::string DeleteAccessLogsDownloadAttributeRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void DeleteAccessLogsDownloadAttributeRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+long DeleteAccessLogsDownloadAttributeRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DeleteAccessLogsDownloadAttributeRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DeleteAccessLogsDownloadAttributeRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DeleteAccessLogsDownloadAttributeRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DeleteAccessLogsDownloadAttributeRequest::getLogsDownloadAttributes() const {
+  return logsDownloadAttributes_;
+}
+
+void DeleteAccessLogsDownloadAttributeRequest::setLogsDownloadAttributes(const std::string &logsDownloadAttributes) {
+  logsDownloadAttributes_ = logsDownloadAttributes;
+  setParameter(std::string("LogsDownloadAttributes"), logsDownloadAttributes);
+}
+
+std::string DeleteAccessLogsDownloadAttributeRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DeleteAccessLogsDownloadAttributeRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DeleteAccessLogsDownloadAttributeRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DeleteAccessLogsDownloadAttributeRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DeleteAccessLogsDownloadAttributeRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DeleteAccessLogsDownloadAttributeRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DeleteAccessLogsDownloadAttributeRequest::getTags() const {
+  return tags_;
+}
+
+void DeleteAccessLogsDownloadAttributeRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+
+std::string DeleteAccessLogsDownloadAttributeRequest::getLoadBalancerId() const {
+  return loadBalancerId_;
+}
+
+void DeleteAccessLogsDownloadAttributeRequest::setLoadBalancerId(const std::string &loadBalancerId) {
+  loadBalancerId_ = loadBalancerId;
+  setParameter(std::string("LoadBalancerId"), loadBalancerId);
+}
+

slb/src/model/DeleteAccessLogsDownloadAttributeResult.cc

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

slb/src/model/DeleteCACertificateRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * 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/DeleteCACertificateRequest.h>
+
+using AlibabaCloud::Slb::Model::DeleteCACertificateRequest;
+
+DeleteCACertificateRequest::DeleteCACertificateRequest()
+    : RpcServiceRequest("slb", "2014-05-15", "DeleteCACertificate") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteCACertificateRequest::~DeleteCACertificateRequest() {}
+
+std::string DeleteCACertificateRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void DeleteCACertificateRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+long DeleteCACertificateRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DeleteCACertificateRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DeleteCACertificateRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DeleteCACertificateRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DeleteCACertificateRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DeleteCACertificateRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DeleteCACertificateRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DeleteCACertificateRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DeleteCACertificateRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DeleteCACertificateRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DeleteCACertificateRequest::getCACertificateId() const {
+  return cACertificateId_;
+}
+
+void DeleteCACertificateRequest::setCACertificateId(const std::string &cACertificateId) {
+  cACertificateId_ = cACertificateId;
+  setParameter(std::string("CACertificateId"), cACertificateId);
+}
+

slb/src/model/DeleteCACertificateResult.cc

@@ -0,0 +1,44 @@
+/*
+ * 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/DeleteCACertificateResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DeleteCACertificateResult::DeleteCACertificateResult() :
+	ServiceResult()
+{}
+
+DeleteCACertificateResult::DeleteCACertificateResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteCACertificateResult::~DeleteCACertificateResult()
+{}
+
+void DeleteCACertificateResult::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,99 @@
+/*
+ * 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") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+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(std::string("access_key_id"), access_key_id);
+}
+
+long DeleteDomainExtensionRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DeleteDomainExtensionRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DeleteDomainExtensionRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DeleteDomainExtensionRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DeleteDomainExtensionRequest::getDomainExtensionId() const {
+  return domainExtensionId_;
+}
+
+void DeleteDomainExtensionRequest::setDomainExtensionId(const std::string &domainExtensionId) {
+  domainExtensionId_ = domainExtensionId;
+  setParameter(std::string("DomainExtensionId"), domainExtensionId);
+}
+
+std::string DeleteDomainExtensionRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DeleteDomainExtensionRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DeleteDomainExtensionRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DeleteDomainExtensionRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DeleteDomainExtensionRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DeleteDomainExtensionRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DeleteDomainExtensionRequest::getTags() const {
+  return tags_;
+}
+
+void DeleteDomainExtensionRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+

slb/src/model/DeleteDomainExtensionResult.cc

@@ -0,0 +1,44 @@
+/*
+ * 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/DeleteLoadBalancerListenerRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::Slb::Model::DeleteLoadBalancerListenerRequest;
 
 DeleteLoadBalancerListenerRequest::DeleteLoadBalancerListenerRequest()
-    : RpcServiceRequest("slb", "2013-02-21", "DeleteLoadBalancerListener") {
+    : RpcServiceRequest("slb", "2014-05-15", "DeleteLoadBalancerListener") {
   setMethod(HttpRequest::Method::Post);
 }
 
@@ -43,13 +43,13 @@ void DeleteLoadBalancerListenerRequest::setResourceOwnerId(long resourceOwnerId)
   setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-std::string DeleteLoadBalancerListenerRequest::getAccessKeyId() const {
-  return accessKeyId_;
+std::string DeleteLoadBalancerListenerRequest::getRegionId() const {
+  return regionId_;
 }
 
-void DeleteLoadBalancerListenerRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
+void DeleteLoadBalancerListenerRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
 int DeleteLoadBalancerListenerRequest::getListenerPort() const {
@@ -88,6 +88,15 @@ void DeleteLoadBalancerListenerRequest::setOwnerId(long ownerId) {
   setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
+std::string DeleteLoadBalancerListenerRequest::getListenerProtocol() const {
+  return listenerProtocol_;
+}
+
+void DeleteLoadBalancerListenerRequest::setListenerProtocol(const std::string &listenerProtocol) {
+  listenerProtocol_ = listenerProtocol;
+  setParameter(std::string("ListenerProtocol"), listenerProtocol);
+}
+
 std::string DeleteLoadBalancerListenerRequest::getTags() const {
   return tags_;
 }

slb/src/model/DeleteLoadBalancerRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::Slb::Model::DeleteLoadBalancerRequest;
 
 DeleteLoadBalancerRequest::DeleteLoadBalancerRequest()
-    : RpcServiceRequest("slb", "2013-02-21", "DeleteLoadBalancer") {
+    : RpcServiceRequest("slb", "2014-05-15", "DeleteLoadBalancer") {
   setMethod(HttpRequest::Method::Post);
 }
 
@@ -43,13 +43,22 @@ void DeleteLoadBalancerRequest::setResourceOwnerId(long resourceOwnerId) {
   setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-std::string DeleteLoadBalancerRequest::getAccessKeyId() const {
-  return accessKeyId_;
+std::string DeleteLoadBalancerRequest::getRegionId() const {
+  return regionId_;
 }
 
-void DeleteLoadBalancerRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
+void DeleteLoadBalancerRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DeleteLoadBalancerRequest::getEnableEipReserve() const {
+  return enableEipReserve_;
+}
+
+void DeleteLoadBalancerRequest::setEnableEipReserve(const std::string &enableEipReserve) {
+  enableEipReserve_ = enableEipReserve;
+  setParameter(std::string("EnableEipReserve"), enableEipReserve);
 }
 
 std::string DeleteLoadBalancerRequest::getResourceOwnerAccount() const {

slb/src/model/DeleteMasterSlaveServerGroupRequest.cc

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

slb/src/model/DeleteMasterSlaveServerGroupResult.cc

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

slb/src/model/DeleteRulesRequest.cc

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

slb/src/model/DeleteRulesResult.cc

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

slb/src/model/DeleteServerCertificateRequest.cc

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

slb/src/model/DeleteServerCertificateResult.cc

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

slb/src/model/DeleteTLSCipherPolicyRequest.cc

@@ -0,0 +1,99 @@
+/*
+ * 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/DeleteTLSCipherPolicyRequest.h>
+
+using AlibabaCloud::Slb::Model::DeleteTLSCipherPolicyRequest;
+
+DeleteTLSCipherPolicyRequest::DeleteTLSCipherPolicyRequest()
+    : RpcServiceRequest("slb", "2014-05-15", "DeleteTLSCipherPolicy") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteTLSCipherPolicyRequest::~DeleteTLSCipherPolicyRequest() {}
+
+std::string DeleteTLSCipherPolicyRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void DeleteTLSCipherPolicyRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+long DeleteTLSCipherPolicyRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DeleteTLSCipherPolicyRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DeleteTLSCipherPolicyRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DeleteTLSCipherPolicyRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string DeleteTLSCipherPolicyRequest::getTLSCipherPolicyId() const {
+  return tLSCipherPolicyId_;
+}
+
+void DeleteTLSCipherPolicyRequest::setTLSCipherPolicyId(const std::string &tLSCipherPolicyId) {
+  tLSCipherPolicyId_ = tLSCipherPolicyId;
+  setParameter(std::string("TLSCipherPolicyId"), tLSCipherPolicyId);
+}
+
+std::string DeleteTLSCipherPolicyRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DeleteTLSCipherPolicyRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DeleteTLSCipherPolicyRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DeleteTLSCipherPolicyRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DeleteTLSCipherPolicyRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DeleteTLSCipherPolicyRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DeleteTLSCipherPolicyRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DeleteTLSCipherPolicyRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

slb/src/model/DeleteTLSCipherPolicyResult.cc

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

slb/src/model/DeleteVServerGroupRequest.cc

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

slb/src/model/DeleteVServerGroupResult.cc

@@ -0,0 +1,44 @@
+/*
+ * 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/DeleteVServerGroupResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DeleteVServerGroupResult::DeleteVServerGroupResult() :
+	ServiceResult()
+{}
+
+DeleteVServerGroupResult::DeleteVServerGroupResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteVServerGroupResult::~DeleteVServerGroupResult()
+{}
+
+void DeleteVServerGroupResult::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,135 @@
+/*
+ * 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") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+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(std::string("access_key_id"), access_key_id);
+}
+
+long DescribeAccessControlListAttributeRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DescribeAccessControlListAttributeRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DescribeAccessControlListAttributeRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DescribeAccessControlListAttributeRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string DescribeAccessControlListAttributeRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeAccessControlListAttributeRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+int DescribeAccessControlListAttributeRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeAccessControlListAttributeRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string DescribeAccessControlListAttributeRequest::getAclId() const {
+  return aclId_;
+}
+
+void DescribeAccessControlListAttributeRequest::setAclId(const std::string &aclId) {
+  aclId_ = aclId;
+  setParameter(std::string("AclId"), aclId);
+}
+
+std::string DescribeAccessControlListAttributeRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DescribeAccessControlListAttributeRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DescribeAccessControlListAttributeRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DescribeAccessControlListAttributeRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::string DescribeAccessControlListAttributeRequest::getAclEntryComment() const {
+  return aclEntryComment_;
+}
+
+void DescribeAccessControlListAttributeRequest::setAclEntryComment(const std::string &aclEntryComment) {
+  aclEntryComment_ = aclEntryComment;
+  setParameter(std::string("AclEntryComment"), aclEntryComment);
+}
+
+long DescribeAccessControlListAttributeRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeAccessControlListAttributeRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DescribeAccessControlListAttributeRequest::getTags() const {
+  return tags_;
+}
+
+void DescribeAccessControlListAttributeRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+
+int DescribeAccessControlListAttributeRequest::getPage() const {
+  return page_;
+}
+
+void DescribeAccessControlListAttributeRequest::setPage(int page) {
+  page_ = page;
+  setParameter(std::string("Page"), std::to_string(page));
+}
+

slb/src/model/DescribeAccessControlListAttributeResult.cc

@@ -0,0 +1,142 @@
+/*
+ * 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 allTagsNode = value["Tags"]["Tag"];
+	for (auto valueTagsTag : allTagsNode)
+	{
+		Tag tagsObject;
+		if(!valueTagsTag["TagKey"].isNull())
+			tagsObject.tagKey = valueTagsTag["TagKey"].asString();
+		if(!valueTagsTag["TagValue"].isNull())
+			tagsObject.tagValue = valueTagsTag["TagValue"].asString();
+		tags_.push_back(tagsObject);
+	}
+	auto allAclEntrysNode = value["AclEntrys"]["AclEntry"];
+	for (auto valueAclEntrysAclEntry : allAclEntrysNode)
+	{
+		AclEntry aclEntrysObject;
+		if(!valueAclEntrysAclEntry["AclEntryComment"].isNull())
+			aclEntrysObject.aclEntryComment = valueAclEntrysAclEntry["AclEntryComment"].asString();
+		if(!valueAclEntrysAclEntry["AclEntryIP"].isNull())
+			aclEntrysObject.aclEntryIP = valueAclEntrysAclEntry["AclEntryIP"].asString();
+		aclEntrys_.push_back(aclEntrysObject);
+	}
+	auto allRelatedListenersNode = value["RelatedListeners"]["RelatedListener"];
+	for (auto valueRelatedListenersRelatedListener : allRelatedListenersNode)
+	{
+		RelatedListener relatedListenersObject;
+		if(!valueRelatedListenersRelatedListener["ListenerPort"].isNull())
+			relatedListenersObject.listenerPort = std::stoi(valueRelatedListenersRelatedListener["ListenerPort"].asString());
+		if(!valueRelatedListenersRelatedListener["AclType"].isNull())
+			relatedListenersObject.aclType = valueRelatedListenersRelatedListener["AclType"].asString();
+		if(!valueRelatedListenersRelatedListener["Protocol"].isNull())
+			relatedListenersObject.protocol = valueRelatedListenersRelatedListener["Protocol"].asString();
+		if(!valueRelatedListenersRelatedListener["LoadBalancerId"].isNull())
+			relatedListenersObject.loadBalancerId = valueRelatedListenersRelatedListener["LoadBalancerId"].asString();
+		relatedListeners_.push_back(relatedListenersObject);
+	}
+	if(!value["ServiceManagedMode"].isNull())
+		serviceManagedMode_ = value["ServiceManagedMode"].asString();
+	if(!value["AclId"].isNull())
+		aclId_ = value["AclId"].asString();
+	if(!value["AddressIPVersion"].isNull())
+		addressIPVersion_ = value["AddressIPVersion"].asString();
+	if(!value["ResourceGroupId"].isNull())
+		resourceGroupId_ = value["ResourceGroupId"].asString();
+	if(!value["AclName"].isNull())
+		aclName_ = value["AclName"].asString();
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["TotalAclEntry"].isNull())
+		totalAclEntry_ = std::stoi(value["TotalAclEntry"].asString());
+
+}
+
+std::vector<DescribeAccessControlListAttributeResult::AclEntry> DescribeAccessControlListAttributeResult::getAclEntrys()const
+{
+	return aclEntrys_;
+}
+
+std::string DescribeAccessControlListAttributeResult::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+int DescribeAccessControlListAttributeResult::getTotalAclEntry()const
+{
+	return totalAclEntry_;
+}
+
+std::string DescribeAccessControlListAttributeResult::getServiceManagedMode()const
+{
+	return serviceManagedMode_;
+}
+
+std::string DescribeAccessControlListAttributeResult::getAclId()const
+{
+	return aclId_;
+}
+
+std::string DescribeAccessControlListAttributeResult::getAddressIPVersion()const
+{
+	return addressIPVersion_;
+}
+
+std::string DescribeAccessControlListAttributeResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+std::vector<DescribeAccessControlListAttributeResult::RelatedListener> DescribeAccessControlListAttributeResult::getRelatedListeners()const
+{
+	return relatedListeners_;
+}
+
+std::vector<DescribeAccessControlListAttributeResult::Tag> DescribeAccessControlListAttributeResult::getTags()const
+{
+	return tags_;
+}
+
+std::string DescribeAccessControlListAttributeResult::getAclName()const
+{
+	return aclName_;
+}
+

slb/src/model/DescribeAccessControlListsRequest.cc

@@ -0,0 +1,158 @@
+/*
+ * 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") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+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(std::string("access_key_id"), access_key_id);
+}
+
+long DescribeAccessControlListsRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DescribeAccessControlListsRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DescribeAccessControlListsRequest::getAclName() const {
+  return aclName_;
+}
+
+void DescribeAccessControlListsRequest::setAclName(const std::string &aclName) {
+  aclName_ = aclName;
+  setParameter(std::string("AclName"), aclName);
+}
+
+std::string DescribeAccessControlListsRequest::getAddressIPVersion() const {
+  return addressIPVersion_;
+}
+
+void DescribeAccessControlListsRequest::setAddressIPVersion(const std::string &addressIPVersion) {
+  addressIPVersion_ = addressIPVersion;
+  setParameter(std::string("AddressIPVersion"), addressIPVersion);
+}
+
+int DescribeAccessControlListsRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeAccessControlListsRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string DescribeAccessControlListsRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DescribeAccessControlListsRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string DescribeAccessControlListsRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void DescribeAccessControlListsRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
+std::string DescribeAccessControlListsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeAccessControlListsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+int DescribeAccessControlListsRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeAccessControlListsRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::vector<DescribeAccessControlListsRequest::Tag> DescribeAccessControlListsRequest::getTag() const {
+  return tag_;
+}
+
+void DescribeAccessControlListsRequest::setTag(const std::vector<DescribeAccessControlListsRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
+std::string DescribeAccessControlListsRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DescribeAccessControlListsRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DescribeAccessControlListsRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DescribeAccessControlListsRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DescribeAccessControlListsRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeAccessControlListsRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DescribeAccessControlListsRequest::getTags() const {
+  return tags_;
+}
+
+void DescribeAccessControlListsRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+

slb/src/model/DescribeAccessControlListsResult.cc

@@ -0,0 +1,105 @@
+/*
+ * 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 allAclsNode = value["Acls"]["Acl"];
+	for (auto valueAclsAcl : allAclsNode)
+	{
+		Acl aclsObject;
+		if(!valueAclsAcl["ServiceManagedMode"].isNull())
+			aclsObject.serviceManagedMode = valueAclsAcl["ServiceManagedMode"].asString();
+		if(!valueAclsAcl["AclId"].isNull())
+			aclsObject.aclId = valueAclsAcl["AclId"].asString();
+		if(!valueAclsAcl["AddressIPVersion"].isNull())
+			aclsObject.addressIPVersion = valueAclsAcl["AddressIPVersion"].asString();
+		if(!valueAclsAcl["AclName"].isNull())
+			aclsObject.aclName = valueAclsAcl["AclName"].asString();
+		if(!valueAclsAcl["ResourceGroupId"].isNull())
+			aclsObject.resourceGroupId = valueAclsAcl["ResourceGroupId"].asString();
+		if(!valueAclsAcl["CreateTime"].isNull())
+			aclsObject.createTime = valueAclsAcl["CreateTime"].asString();
+		auto allTagsNode = valueAclsAcl["Tags"]["Tag"];
+		for (auto valueAclsAclTagsTag : allTagsNode)
+		{
+			Acl::Tag tagsObject;
+			if(!valueAclsAclTagsTag["TagValue"].isNull())
+				tagsObject.tagValue = valueAclsAclTagsTag["TagValue"].asString();
+			if(!valueAclsAclTagsTag["TagKey"].isNull())
+				tagsObject.tagKey = valueAclsAclTagsTag["TagKey"].asString();
+			aclsObject.tags.push_back(tagsObject);
+		}
+		acls_.push_back(aclsObject);
+	}
+	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());
+	if(!value["Count"].isNull())
+		count_ = std::stoi(value["Count"].asString());
+
+}
+
+int DescribeAccessControlListsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeAccessControlListsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeAccessControlListsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeAccessControlListsResult::Acl> DescribeAccessControlListsResult::getAcls()const
+{
+	return acls_;
+}
+
+int DescribeAccessControlListsResult::getCount()const
+{
+	return count_;
+}
+

slb/src/model/DescribeAccessLogsDownloadAttributeRequest.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/DescribeAccessLogsDownloadAttributeRequest.h>
+
+using AlibabaCloud::Slb::Model::DescribeAccessLogsDownloadAttributeRequest;
+
+DescribeAccessLogsDownloadAttributeRequest::DescribeAccessLogsDownloadAttributeRequest()
+    : RpcServiceRequest("slb", "2014-05-15", "DescribeAccessLogsDownloadAttribute") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeAccessLogsDownloadAttributeRequest::~DescribeAccessLogsDownloadAttributeRequest() {}
+
+std::string DescribeAccessLogsDownloadAttributeRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void DescribeAccessLogsDownloadAttributeRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+long DescribeAccessLogsDownloadAttributeRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DescribeAccessLogsDownloadAttributeRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+int DescribeAccessLogsDownloadAttributeRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeAccessLogsDownloadAttributeRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string DescribeAccessLogsDownloadAttributeRequest::getLogType() const {
+  return logType_;
+}
+
+void DescribeAccessLogsDownloadAttributeRequest::setLogType(const std::string &logType) {
+  logType_ = logType;
+  setParameter(std::string("LogType"), logType);
+}
+
+std::string DescribeAccessLogsDownloadAttributeRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeAccessLogsDownloadAttributeRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+int DescribeAccessLogsDownloadAttributeRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeAccessLogsDownloadAttributeRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string DescribeAccessLogsDownloadAttributeRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DescribeAccessLogsDownloadAttributeRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DescribeAccessLogsDownloadAttributeRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DescribeAccessLogsDownloadAttributeRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DescribeAccessLogsDownloadAttributeRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeAccessLogsDownloadAttributeRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DescribeAccessLogsDownloadAttributeRequest::getTags() const {
+  return tags_;
+}
+
+void DescribeAccessLogsDownloadAttributeRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+
+std::string DescribeAccessLogsDownloadAttributeRequest::getLoadBalancerId() const {
+  return loadBalancerId_;
+}
+
+void DescribeAccessLogsDownloadAttributeRequest::setLoadBalancerId(const std::string &loadBalancerId) {
+  loadBalancerId_ = loadBalancerId;
+  setParameter(std::string("LoadBalancerId"), loadBalancerId);
+}
+

slb/src/model/DescribeAccessLogsDownloadAttributeResult.cc

@@ -0,0 +1,95 @@
+/*
+ * 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/DescribeAccessLogsDownloadAttributeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DescribeAccessLogsDownloadAttributeResult::DescribeAccessLogsDownloadAttributeResult() :
+	ServiceResult()
+{}
+
+DescribeAccessLogsDownloadAttributeResult::DescribeAccessLogsDownloadAttributeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeAccessLogsDownloadAttributeResult::~DescribeAccessLogsDownloadAttributeResult()
+{}
+
+void DescribeAccessLogsDownloadAttributeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allLogsDownloadAttributesNode = value["LogsDownloadAttributes"]["LogsDownloadAttribute"];
+	for (auto valueLogsDownloadAttributesLogsDownloadAttribute : allLogsDownloadAttributesNode)
+	{
+		LogsDownloadAttribute logsDownloadAttributesObject;
+		if(!valueLogsDownloadAttributesLogsDownloadAttribute["LogProject"].isNull())
+			logsDownloadAttributesObject.logProject = valueLogsDownloadAttributesLogsDownloadAttribute["LogProject"].asString();
+		if(!valueLogsDownloadAttributesLogsDownloadAttribute["RoleArn"].isNull())
+			logsDownloadAttributesObject.roleArn = valueLogsDownloadAttributesLogsDownloadAttribute["RoleArn"].asString();
+		if(!valueLogsDownloadAttributesLogsDownloadAttribute["LogStore"].isNull())
+			logsDownloadAttributesObject.logStore = valueLogsDownloadAttributesLogsDownloadAttribute["LogStore"].asString();
+		if(!valueLogsDownloadAttributesLogsDownloadAttribute["LoadBalancerId"].isNull())
+			logsDownloadAttributesObject.loadBalancerId = valueLogsDownloadAttributesLogsDownloadAttribute["LoadBalancerId"].asString();
+		if(!valueLogsDownloadAttributesLogsDownloadAttribute["Region"].isNull())
+			logsDownloadAttributesObject.region = valueLogsDownloadAttributesLogsDownloadAttribute["Region"].asString();
+		if(!valueLogsDownloadAttributesLogsDownloadAttribute["LogType"].isNull())
+			logsDownloadAttributesObject.logType = valueLogsDownloadAttributesLogsDownloadAttribute["LogType"].asString();
+		logsDownloadAttributes_.push_back(logsDownloadAttributesObject);
+	}
+	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());
+	if(!value["Count"].isNull())
+		count_ = std::stoi(value["Count"].asString());
+
+}
+
+int DescribeAccessLogsDownloadAttributeResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeAccessLogsDownloadAttributeResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeAccessLogsDownloadAttributeResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+int DescribeAccessLogsDownloadAttributeResult::getCount()const
+{
+	return count_;
+}
+
+std::vector<DescribeAccessLogsDownloadAttributeResult::LogsDownloadAttribute> DescribeAccessLogsDownloadAttributeResult::getLogsDownloadAttributes()const
+{
+	return logsDownloadAttributes_;
+}
+

slb/src/model/DescribeAvailableResourceRequest.cc

@@ -0,0 +1,99 @@
+/*
+ * 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/DescribeAvailableResourceRequest.h>
+
+using AlibabaCloud::Slb::Model::DescribeAvailableResourceRequest;
+
+DescribeAvailableResourceRequest::DescribeAvailableResourceRequest()
+    : RpcServiceRequest("slb", "2014-05-15", "DescribeAvailableResource") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeAvailableResourceRequest::~DescribeAvailableResourceRequest() {}
+
+std::string DescribeAvailableResourceRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void DescribeAvailableResourceRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+long DescribeAvailableResourceRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DescribeAvailableResourceRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DescribeAvailableResourceRequest::getAddressIPVersion() const {
+  return addressIPVersion_;
+}
+
+void DescribeAvailableResourceRequest::setAddressIPVersion(const std::string &addressIPVersion) {
+  addressIPVersion_ = addressIPVersion;
+  setParameter(std::string("AddressIPVersion"), addressIPVersion);
+}
+
+std::string DescribeAvailableResourceRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeAvailableResourceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeAvailableResourceRequest::getAddressType() const {
+  return addressType_;
+}
+
+void DescribeAvailableResourceRequest::setAddressType(const std::string &addressType) {
+  addressType_ = addressType;
+  setParameter(std::string("AddressType"), addressType);
+}
+
+std::string DescribeAvailableResourceRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DescribeAvailableResourceRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DescribeAvailableResourceRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DescribeAvailableResourceRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DescribeAvailableResourceRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeAvailableResourceRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

slb/src/model/DescribeAvailableResourceResult.cc

@@ -0,0 +1,69 @@
+/*
+ * 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/DescribeAvailableResourceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DescribeAvailableResourceResult::DescribeAvailableResourceResult() :
+	ServiceResult()
+{}
+
+DescribeAvailableResourceResult::DescribeAvailableResourceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeAvailableResourceResult::~DescribeAvailableResourceResult()
+{}
+
+void DescribeAvailableResourceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allAvailableResourcesNode = value["AvailableResources"]["AvailableResource"];
+	for (auto valueAvailableResourcesAvailableResource : allAvailableResourcesNode)
+	{
+		AvailableResource availableResourcesObject;
+		if(!valueAvailableResourcesAvailableResource["SlaveZoneId"].isNull())
+			availableResourcesObject.slaveZoneId = valueAvailableResourcesAvailableResource["SlaveZoneId"].asString();
+		if(!valueAvailableResourcesAvailableResource["MasterZoneId"].isNull())
+			availableResourcesObject.masterZoneId = valueAvailableResourcesAvailableResource["MasterZoneId"].asString();
+		auto allSupportResourcesNode = valueAvailableResourcesAvailableResource["SupportResources"]["SupportResource"];
+		for (auto valueAvailableResourcesAvailableResourceSupportResourcesSupportResource : allSupportResourcesNode)
+		{
+			AvailableResource::SupportResource supportResourcesObject;
+			if(!valueAvailableResourcesAvailableResourceSupportResourcesSupportResource["AddressType"].isNull())
+				supportResourcesObject.addressType = valueAvailableResourcesAvailableResourceSupportResourcesSupportResource["AddressType"].asString();
+			if(!valueAvailableResourcesAvailableResourceSupportResourcesSupportResource["AddressIPVersion"].isNull())
+				supportResourcesObject.addressIPVersion = valueAvailableResourcesAvailableResourceSupportResourcesSupportResource["AddressIPVersion"].asString();
+			availableResourcesObject.supportResources.push_back(supportResourcesObject);
+		}
+		availableResources_.push_back(availableResourcesObject);
+	}
+
+}
+
+std::vector<DescribeAvailableResourceResult::AvailableResource> DescribeAvailableResourceResult::getAvailableResources()const
+{
+	return availableResources_;
+}
+

slb/src/model/DescribeBackendServersRequest.cc

@@ -1,117 +0,0 @@
-/*
- * 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/DescribeBackendServersRequest.h>
-
-using AlibabaCloud::Slb::Model::DescribeBackendServersRequest;
-
-DescribeBackendServersRequest::DescribeBackendServersRequest()
-    : RpcServiceRequest("slb", "2013-02-21", "DescribeBackendServers") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-DescribeBackendServersRequest::~DescribeBackendServersRequest() {}
-
-std::string DescribeBackendServersRequest::getAccess_key_id() const {
-  return access_key_id_;
-}
-
-void DescribeBackendServersRequest::setAccess_key_id(const std::string &access_key_id) {
-  access_key_id_ = access_key_id;
-  setParameter(std::string("access_key_id"), access_key_id);
-}
-
-long DescribeBackendServersRequest::getResourceOwnerId() const {
-  return resourceOwnerId_;
-}
-
-void DescribeBackendServersRequest::setResourceOwnerId(long resourceOwnerId) {
-  resourceOwnerId_ = resourceOwnerId;
-  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
-}
-
-std::string DescribeBackendServersRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void DescribeBackendServersRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string DescribeBackendServersRequest::getRegionId() const {
-  return regionId_;
-}
-
-void DescribeBackendServersRequest::setRegionId(const std::string &regionId) {
-  regionId_ = regionId;
-  setParameter(std::string("RegionId"), regionId);
-}
-
-int DescribeBackendServersRequest::getListenerPort() const {
-  return listenerPort_;
-}
-
-void DescribeBackendServersRequest::setListenerPort(int listenerPort) {
-  listenerPort_ = listenerPort;
-  setParameter(std::string("ListenerPort"), std::to_string(listenerPort));
-}
-
-std::string DescribeBackendServersRequest::getResourceOwnerAccount() const {
-  return resourceOwnerAccount_;
-}
-
-void DescribeBackendServersRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
-  resourceOwnerAccount_ = resourceOwnerAccount;
-  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
-}
-
-std::string DescribeBackendServersRequest::getOwnerAccount() const {
-  return ownerAccount_;
-}
-
-void DescribeBackendServersRequest::setOwnerAccount(const std::string &ownerAccount) {
-  ownerAccount_ = ownerAccount;
-  setParameter(std::string("OwnerAccount"), ownerAccount);
-}
-
-long DescribeBackendServersRequest::getOwnerId() const {
-  return ownerId_;
-}
-
-void DescribeBackendServersRequest::setOwnerId(long ownerId) {
-  ownerId_ = ownerId;
-  setParameter(std::string("OwnerId"), std::to_string(ownerId));
-}
-
-std::string DescribeBackendServersRequest::getTags() const {
-  return tags_;
-}
-
-void DescribeBackendServersRequest::setTags(const std::string &tags) {
-  tags_ = tags;
-  setParameter(std::string("Tags"), tags);
-}
-
-std::string DescribeBackendServersRequest::getLoadBalancerId() const {
-  return loadBalancerId_;
-}
-
-void DescribeBackendServersRequest::setLoadBalancerId(const std::string &loadBalancerId) {
-  loadBalancerId_ = loadBalancerId;
-  setParameter(std::string("LoadBalancerId"), loadBalancerId);
-}
-

slb/src/model/DescribeBackendServersResult.cc

@@ -1,67 +0,0 @@
-/*
- * 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/DescribeBackendServersResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Slb;
-using namespace AlibabaCloud::Slb::Model;
-
-DescribeBackendServersResult::DescribeBackendServersResult() :
-	ServiceResult()
-{}
-
-DescribeBackendServersResult::DescribeBackendServersResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeBackendServersResult::~DescribeBackendServersResult()
-{}
-
-void DescribeBackendServersResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allListenersNode = value["Listeners"]["Listener"];
-	for (auto valueListenersListener : allListenersNode)
-	{
-		Listener listenersObject;
-		if(!valueListenersListener["ListenerPort"].isNull())
-			listenersObject.listenerPort = std::stoi(valueListenersListener["ListenerPort"].asString());
-		auto allBackendServersNode = valueListenersListener["BackendServers"]["BackendServer"];
-		for (auto valueListenersListenerBackendServersBackendServer : allBackendServersNode)
-		{
-			Listener::BackendServer backendServersObject;
-			if(!valueListenersListenerBackendServersBackendServer["ServerHealthStatus"].isNull())
-				backendServersObject.serverHealthStatus = valueListenersListenerBackendServersBackendServer["ServerHealthStatus"].asString();
-			if(!valueListenersListenerBackendServersBackendServer["ServerId"].isNull())
-				backendServersObject.serverId = valueListenersListenerBackendServersBackendServer["ServerId"].asString();
-			listenersObject.backendServers.push_back(backendServersObject);
-		}
-		listeners_.push_back(listenersObject);
-	}
-
-}
-
-std::vector<DescribeBackendServersResult::Listener> DescribeBackendServersResult::getListeners()const
-{
-	return listeners_;
-}
-

slb/src/model/DescribeCACertificatesRequest.cc

@@ -0,0 +1,113 @@
+/*
+ * 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/DescribeCACertificatesRequest.h>
+
+using AlibabaCloud::Slb::Model::DescribeCACertificatesRequest;
+
+DescribeCACertificatesRequest::DescribeCACertificatesRequest()
+    : RpcServiceRequest("slb", "2014-05-15", "DescribeCACertificates") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeCACertificatesRequest::~DescribeCACertificatesRequest() {}
+
+std::string DescribeCACertificatesRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void DescribeCACertificatesRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+long DescribeCACertificatesRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DescribeCACertificatesRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DescribeCACertificatesRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void DescribeCACertificatesRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
+std::string DescribeCACertificatesRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeCACertificatesRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::vector<DescribeCACertificatesRequest::Tag> DescribeCACertificatesRequest::getTag() const {
+  return tag_;
+}
+
+void DescribeCACertificatesRequest::setTag(const std::vector<DescribeCACertificatesRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
+std::string DescribeCACertificatesRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DescribeCACertificatesRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DescribeCACertificatesRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DescribeCACertificatesRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DescribeCACertificatesRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeCACertificatesRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DescribeCACertificatesRequest::getCACertificateId() const {
+  return cACertificateId_;
+}
+
+void DescribeCACertificatesRequest::setCACertificateId(const std::string &cACertificateId) {
+  cACertificateId_ = cACertificateId;
+  setParameter(std::string("CACertificateId"), cACertificateId);
+}
+

slb/src/model/DescribeCACertificatesResult.cc

@@ -0,0 +1,91 @@
+/*
+ * 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/DescribeCACertificatesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DescribeCACertificatesResult::DescribeCACertificatesResult() :
+	ServiceResult()
+{}
+
+DescribeCACertificatesResult::DescribeCACertificatesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeCACertificatesResult::~DescribeCACertificatesResult()
+{}
+
+void DescribeCACertificatesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allCACertificatesNode = value["CACertificates"]["CACertificate"];
+	for (auto valueCACertificatesCACertificate : allCACertificatesNode)
+	{
+		CACertificate cACertificatesObject;
+		if(!valueCACertificatesCACertificate["CreateTimeStamp"].isNull())
+			cACertificatesObject.createTimeStamp = std::stol(valueCACertificatesCACertificate["CreateTimeStamp"].asString());
+		if(!valueCACertificatesCACertificate["StandardType"].isNull())
+			cACertificatesObject.standardType = valueCACertificatesCACertificate["StandardType"].asString();
+		if(!valueCACertificatesCACertificate["ExpireTime"].isNull())
+			cACertificatesObject.expireTime = valueCACertificatesCACertificate["ExpireTime"].asString();
+		if(!valueCACertificatesCACertificate["CreateTime"].isNull())
+			cACertificatesObject.createTime = valueCACertificatesCACertificate["CreateTime"].asString();
+		if(!valueCACertificatesCACertificate["EncryptionKeyLength"].isNull())
+			cACertificatesObject.encryptionKeyLength = std::stoi(valueCACertificatesCACertificate["EncryptionKeyLength"].asString());
+		if(!valueCACertificatesCACertificate["ExpireTimeStamp"].isNull())
+			cACertificatesObject.expireTimeStamp = std::stol(valueCACertificatesCACertificate["ExpireTimeStamp"].asString());
+		if(!valueCACertificatesCACertificate["CACertificateId"].isNull())
+			cACertificatesObject.cACertificateId = valueCACertificatesCACertificate["CACertificateId"].asString();
+		if(!valueCACertificatesCACertificate["RegionId"].isNull())
+			cACertificatesObject.regionId = valueCACertificatesCACertificate["RegionId"].asString();
+		if(!valueCACertificatesCACertificate["EncryptionAlgorithm"].isNull())
+			cACertificatesObject.encryptionAlgorithm = valueCACertificatesCACertificate["EncryptionAlgorithm"].asString();
+		if(!valueCACertificatesCACertificate["Fingerprint"].isNull())
+			cACertificatesObject.fingerprint = valueCACertificatesCACertificate["Fingerprint"].asString();
+		if(!valueCACertificatesCACertificate["ResourceGroupId"].isNull())
+			cACertificatesObject.resourceGroupId = valueCACertificatesCACertificate["ResourceGroupId"].asString();
+		if(!valueCACertificatesCACertificate["CommonName"].isNull())
+			cACertificatesObject.commonName = valueCACertificatesCACertificate["CommonName"].asString();
+		if(!valueCACertificatesCACertificate["CACertificateName"].isNull())
+			cACertificatesObject.cACertificateName = valueCACertificatesCACertificate["CACertificateName"].asString();
+		auto allTagsNode = valueCACertificatesCACertificate["Tags"]["Tag"];
+		for (auto valueCACertificatesCACertificateTagsTag : allTagsNode)
+		{
+			CACertificate::Tag tagsObject;
+			if(!valueCACertificatesCACertificateTagsTag["TagValue"].isNull())
+				tagsObject.tagValue = valueCACertificatesCACertificateTagsTag["TagValue"].asString();
+			if(!valueCACertificatesCACertificateTagsTag["TagKey"].isNull())
+				tagsObject.tagKey = valueCACertificatesCACertificateTagsTag["TagKey"].asString();
+			cACertificatesObject.tags.push_back(tagsObject);
+		}
+		cACertificates_.push_back(cACertificatesObject);
+	}
+
+}
+
+std::vector<DescribeCACertificatesResult::CACertificate> DescribeCACertificatesResult::getCACertificates()const
+{
+	return cACertificates_;
+}
+

slb/src/model/DescribeDomainExtensionAttributeRequest.cc

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

slb/src/model/DescribeDomainExtensionAttributeResult.cc

@@ -0,0 +1,113 @@
+/*
+ * 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/DescribeDomainExtensionAttributeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DescribeDomainExtensionAttributeResult::DescribeDomainExtensionAttributeResult() :
+	ServiceResult()
+{}
+
+DescribeDomainExtensionAttributeResult::DescribeDomainExtensionAttributeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDomainExtensionAttributeResult::~DescribeDomainExtensionAttributeResult()
+{}
+
+void DescribeDomainExtensionAttributeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allCertificatesNode = value["Certificates"]["Certificate"];
+	for (auto valueCertificatesCertificate : allCertificatesNode)
+	{
+		Certificate certificatesObject;
+		if(!valueCertificatesCertificate["EncryptionAlgorithm"].isNull())
+			certificatesObject.encryptionAlgorithm = valueCertificatesCertificate["EncryptionAlgorithm"].asString();
+		if(!valueCertificatesCertificate["CertificateId"].isNull())
+			certificatesObject.certificateId = valueCertificatesCertificate["CertificateId"].asString();
+		certificates_.push_back(certificatesObject);
+	}
+	auto allServerCertificatesNode = value["ServerCertificates"]["ServerCertificate"];
+	for (auto valueServerCertificatesServerCertificate : allServerCertificatesNode)
+	{
+		ServerCertificate serverCertificatesObject;
+		if(!valueServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
+			serverCertificatesObject.encryptionAlgorithm = valueServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
+		if(!valueServerCertificatesServerCertificate["StandardType"].isNull())
+			serverCertificatesObject.standardType = valueServerCertificatesServerCertificate["StandardType"].asString();
+		if(!valueServerCertificatesServerCertificate["BindingType"].isNull())
+			serverCertificatesObject.bindingType = valueServerCertificatesServerCertificate["BindingType"].asString();
+		if(!valueServerCertificatesServerCertificate["CertificateId"].isNull())
+			serverCertificatesObject.certificateId = valueServerCertificatesServerCertificate["CertificateId"].asString();
+		serverCertificates_.push_back(serverCertificatesObject);
+	}
+	if(!value["Domain"].isNull())
+		domain_ = value["Domain"].asString();
+	if(!value["LoadBalancerId"].isNull())
+		loadBalancerId_ = value["LoadBalancerId"].asString();
+	if(!value["ListenerPort"].isNull())
+		listenerPort_ = std::stoi(value["ListenerPort"].asString());
+	if(!value["ServerCertificateId"].isNull())
+		serverCertificateId_ = value["ServerCertificateId"].asString();
+	if(!value["DomainExtensionId"].isNull())
+		domainExtensionId_ = value["DomainExtensionId"].asString();
+
+}
+
+int DescribeDomainExtensionAttributeResult::getListenerPort()const
+{
+	return listenerPort_;
+}
+
+std::string DescribeDomainExtensionAttributeResult::getDomainExtensionId()const
+{
+	return domainExtensionId_;
+}
+
+std::vector<DescribeDomainExtensionAttributeResult::Certificate> DescribeDomainExtensionAttributeResult::getCertificates()const
+{
+	return certificates_;
+}
+
+std::vector<DescribeDomainExtensionAttributeResult::ServerCertificate> DescribeDomainExtensionAttributeResult::getServerCertificates()const
+{
+	return serverCertificates_;
+}
+
+std::string DescribeDomainExtensionAttributeResult::getServerCertificateId()const
+{
+	return serverCertificateId_;
+}
+
+std::string DescribeDomainExtensionAttributeResult::getLoadBalancerId()const
+{
+	return loadBalancerId_;
+}
+
+std::string DescribeDomainExtensionAttributeResult::getDomain()const
+{
+	return domain_;
+}
+

slb/src/model/DescribeDomainExtensionsRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * 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") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+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(std::string("access_key_id"), access_key_id);
+}
+
+long DescribeDomainExtensionsRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DescribeDomainExtensionsRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DescribeDomainExtensionsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeDomainExtensionsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeDomainExtensionsRequest::getDomainExtensionId() const {
+  return domainExtensionId_;
+}
+
+void DescribeDomainExtensionsRequest::setDomainExtensionId(const std::string &domainExtensionId) {
+  domainExtensionId_ = domainExtensionId;
+  setParameter(std::string("DomainExtensionId"), domainExtensionId);
+}
+
+int DescribeDomainExtensionsRequest::getListenerPort() const {
+  return listenerPort_;
+}
+
+void DescribeDomainExtensionsRequest::setListenerPort(int listenerPort) {
+  listenerPort_ = listenerPort;
+  setParameter(std::string("ListenerPort"), std::to_string(listenerPort));
+}
+
+std::string DescribeDomainExtensionsRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DescribeDomainExtensionsRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DescribeDomainExtensionsRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DescribeDomainExtensionsRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DescribeDomainExtensionsRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeDomainExtensionsRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DescribeDomainExtensionsRequest::getTags() const {
+  return tags_;
+}
+
+void DescribeDomainExtensionsRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+
+std::string DescribeDomainExtensionsRequest::getLoadBalancerId() const {
+  return loadBalancerId_;
+}
+
+void DescribeDomainExtensionsRequest::setLoadBalancerId(const std::string &loadBalancerId) {
+  loadBalancerId_ = loadBalancerId;
+  setParameter(std::string("LoadBalancerId"), loadBalancerId);
+}
+

slb/src/model/DescribeDomainExtensionsResult.cc

@@ -0,0 +1,85 @@
+/*
+ * 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 allDomainExtensionsNode = value["DomainExtensions"]["DomainExtension"];
+	for (auto valueDomainExtensionsDomainExtension : allDomainExtensionsNode)
+	{
+		DomainExtension domainExtensionsObject;
+		if(!valueDomainExtensionsDomainExtension["ServerCertificateId"].isNull())
+			domainExtensionsObject.serverCertificateId = valueDomainExtensionsDomainExtension["ServerCertificateId"].asString();
+		if(!valueDomainExtensionsDomainExtension["Domain"].isNull())
+			domainExtensionsObject.domain = valueDomainExtensionsDomainExtension["Domain"].asString();
+		if(!valueDomainExtensionsDomainExtension["DomainExtensionId"].isNull())
+			domainExtensionsObject.domainExtensionId = valueDomainExtensionsDomainExtension["DomainExtensionId"].asString();
+		auto allCertificatesNode = valueDomainExtensionsDomainExtension["Certificates"]["Certificate"];
+		for (auto valueDomainExtensionsDomainExtensionCertificatesCertificate : allCertificatesNode)
+		{
+			DomainExtension::Certificate certificatesObject;
+			if(!valueDomainExtensionsDomainExtensionCertificatesCertificate["EncryptionAlgorithm"].isNull())
+				certificatesObject.encryptionAlgorithm = valueDomainExtensionsDomainExtensionCertificatesCertificate["EncryptionAlgorithm"].asString();
+			if(!valueDomainExtensionsDomainExtensionCertificatesCertificate["CertificateId"].isNull())
+				certificatesObject.certificateId = valueDomainExtensionsDomainExtensionCertificatesCertificate["CertificateId"].asString();
+			domainExtensionsObject.certificates.push_back(certificatesObject);
+		}
+		auto allServerCertificatesNode = valueDomainExtensionsDomainExtension["ServerCertificates"]["ServerCertificate"];
+		for (auto valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate : allServerCertificatesNode)
+		{
+			DomainExtension::ServerCertificate serverCertificatesObject;
+			if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
+				serverCertificatesObject.encryptionAlgorithm = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
+			if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["StandardType"].isNull())
+				serverCertificatesObject.standardType = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["StandardType"].asString();
+			if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["CertificateId"].isNull())
+				serverCertificatesObject.certificateId = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["CertificateId"].asString();
+			if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["BindingType"].isNull())
+				serverCertificatesObject.bindingType = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["BindingType"].asString();
+			domainExtensionsObject.serverCertificates.push_back(serverCertificatesObject);
+		}
+		domainExtensions_.push_back(domainExtensionsObject);
+	}
+
+}
+
+std::vector<DescribeDomainExtensionsResult::DomainExtension> DescribeDomainExtensionsResult::getDomainExtensions()const
+{
+	return domainExtensions_;
+}
+

slb/src/model/DescribeHealthStatusRequest.cc

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

slb/src/model/DescribeHealthStatusResult.cc

@@ -0,0 +1,71 @@
+/*
+ * 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/DescribeHealthStatusResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DescribeHealthStatusResult::DescribeHealthStatusResult() :
+	ServiceResult()
+{}
+
+DescribeHealthStatusResult::DescribeHealthStatusResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeHealthStatusResult::~DescribeHealthStatusResult()
+{}
+
+void DescribeHealthStatusResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allBackendServersNode = value["BackendServers"]["BackendServer"];
+	for (auto valueBackendServersBackendServer : allBackendServersNode)
+	{
+		BackendServer backendServersObject;
+		if(!valueBackendServersBackendServer["Type"].isNull())
+			backendServersObject.type = valueBackendServersBackendServer["Type"].asString();
+		if(!valueBackendServersBackendServer["EniHost"].isNull())
+			backendServersObject.eniHost = valueBackendServersBackendServer["EniHost"].asString();
+		if(!valueBackendServersBackendServer["Protocol"].isNull())
+			backendServersObject.protocol = valueBackendServersBackendServer["Protocol"].asString();
+		if(!valueBackendServersBackendServer["ServerHealthStatus"].isNull())
+			backendServersObject.serverHealthStatus = valueBackendServersBackendServer["ServerHealthStatus"].asString();
+		if(!valueBackendServersBackendServer["ListenerPort"].isNull())
+			backendServersObject.listenerPort = std::stoi(valueBackendServersBackendServer["ListenerPort"].asString());
+		if(!valueBackendServersBackendServer["ServerIp"].isNull())
+			backendServersObject.serverIp = valueBackendServersBackendServer["ServerIp"].asString();
+		if(!valueBackendServersBackendServer["Port"].isNull())
+			backendServersObject.port = std::stoi(valueBackendServersBackendServer["Port"].asString());
+		if(!valueBackendServersBackendServer["ServerId"].isNull())
+			backendServersObject.serverId = valueBackendServersBackendServer["ServerId"].asString();
+		backendServers_.push_back(backendServersObject);
+	}
+
+}
+
+std::vector<DescribeHealthStatusResult::BackendServer> DescribeHealthStatusResult::getBackendServers()const
+{
+	return backendServers_;
+}
+

slb/src/model/DescribeHighDefinationMonitorRequest.cc

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

slb/src/model/DescribeHighDefinationMonitorResult.cc

@@ -0,0 +1,65 @@
+/*
+ * 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/DescribeHighDefinationMonitorResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DescribeHighDefinationMonitorResult::DescribeHighDefinationMonitorResult() :
+	ServiceResult()
+{}
+
+DescribeHighDefinationMonitorResult::DescribeHighDefinationMonitorResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeHighDefinationMonitorResult::~DescribeHighDefinationMonitorResult()
+{}
+
+void DescribeHighDefinationMonitorResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["LogProject"].isNull())
+		logProject_ = value["LogProject"].asString();
+	if(!value["LogStore"].isNull())
+		logStore_ = value["LogStore"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString();
+
+}
+
+std::string DescribeHighDefinationMonitorResult::getLogStore()const
+{
+	return logStore_;
+}
+
+std::string DescribeHighDefinationMonitorResult::getLogProject()const
+{
+	return logProject_;
+}
+
+std::string DescribeHighDefinationMonitorResult::getSuccess()const
+{
+	return success_;
+}
+

slb/src/model/DescribeListenerAccessControlAttributeRequest.cc

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

slb/src/model/DescribeListenerAccessControlAttributeResult.cc

@@ -0,0 +1,58 @@
+/*
+ * 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/DescribeListenerAccessControlAttributeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DescribeListenerAccessControlAttributeResult::DescribeListenerAccessControlAttributeResult() :
+	ServiceResult()
+{}
+
+DescribeListenerAccessControlAttributeResult::DescribeListenerAccessControlAttributeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeListenerAccessControlAttributeResult::~DescribeListenerAccessControlAttributeResult()
+{}
+
+void DescribeListenerAccessControlAttributeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["SourceItems"].isNull())
+		sourceItems_ = value["SourceItems"].asString();
+	if(!value["AccessControlStatus"].isNull())
+		accessControlStatus_ = value["AccessControlStatus"].asString();
+
+}
+
+std::string DescribeListenerAccessControlAttributeResult::getAccessControlStatus()const
+{
+	return accessControlStatus_;
+}
+
+std::string DescribeListenerAccessControlAttributeResult::getSourceItems()const
+{
+	return sourceItems_;
+}
+

slb/src/model/DescribeLoadBalancerAttributeRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::Slb::Model::DescribeLoadBalancerAttributeRequest;
 
 DescribeLoadBalancerAttributeRequest::DescribeLoadBalancerAttributeRequest()
-    : RpcServiceRequest("slb", "2013-02-21", "DescribeLoadBalancerAttribute") {
+    : RpcServiceRequest("slb", "2014-05-15", "DescribeLoadBalancerAttribute") {
   setMethod(HttpRequest::Method::Post);
 }
 
@@ -43,13 +43,22 @@ void DescribeLoadBalancerAttributeRequest::setResourceOwnerId(long resourceOwner
   setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-std::string DescribeLoadBalancerAttributeRequest::getAccessKeyId() const {
-  return accessKeyId_;
+bool DescribeLoadBalancerAttributeRequest::getIncludeReservedData() const {
+  return includeReservedData_;
 }
 
-void DescribeLoadBalancerAttributeRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
+void DescribeLoadBalancerAttributeRequest::setIncludeReservedData(bool includeReservedData) {
+  includeReservedData_ = includeReservedData;
+  setParameter(std::string("IncludeReservedData"), includeReservedData ? "true" : "false");
+}
+
+std::string DescribeLoadBalancerAttributeRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeLoadBalancerAttributeRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
 std::string DescribeLoadBalancerAttributeRequest::getResourceOwnerAccount() const {

slb/src/model/DescribeLoadBalancerAttributeResult.cc

@@ -39,6 +39,16 @@ void DescribeLoadBalancerAttributeResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	auto allTagsNode = value["Tags"]["Tag"];
+	for (auto valueTagsTag : allTagsNode)
+	{
+		Tag tagsObject;
+		if(!valueTagsTag["TagKey"].isNull())
+			tagsObject.tagKey = valueTagsTag["TagKey"].asString();
+		if(!valueTagsTag["TagValue"].isNull())
+			tagsObject.tagValue = valueTagsTag["TagValue"].asString();
+		tags_.push_back(tagsObject);
+	}
 	auto allListenerPortsAndProtocalNode = value["ListenerPortsAndProtocal"]["ListenerPortAndProtocal"];
 	for (auto valueListenerPortsAndProtocalListenerPortAndProtocal : allListenerPortsAndProtocalNode)
 	{
@@ -57,18 +67,35 @@ void DescribeLoadBalancerAttributeResult::parse(const std::string &payload)
 			listenerPortsAndProtocolObject.listenerPort = std::stoi(valueListenerPortsAndProtocolListenerPortAndProtocol["ListenerPort"].asString());
 		if(!valueListenerPortsAndProtocolListenerPortAndProtocol["ListenerProtocol"].isNull())
 			listenerPortsAndProtocolObject.listenerProtocol = valueListenerPortsAndProtocolListenerPortAndProtocol["ListenerProtocol"].asString();
+		if(!valueListenerPortsAndProtocolListenerPortAndProtocol["ListenerForward"].isNull())
+			listenerPortsAndProtocolObject.listenerForward = valueListenerPortsAndProtocolListenerPortAndProtocol["ListenerForward"].asString();
+		if(!valueListenerPortsAndProtocolListenerPortAndProtocol["Description"].isNull())
+			listenerPortsAndProtocolObject.description = valueListenerPortsAndProtocolListenerPortAndProtocol["Description"].asString();
+		if(!valueListenerPortsAndProtocolListenerPortAndProtocol["ForwardPort"].isNull())
+			listenerPortsAndProtocolObject.forwardPort = std::stoi(valueListenerPortsAndProtocolListenerPortAndProtocol["ForwardPort"].asString());
 		listenerPortsAndProtocol_.push_back(listenerPortsAndProtocolObject);
 	}
 	auto allBackendServersNode = value["BackendServers"]["BackendServer"];
 	for (auto valueBackendServersBackendServer : allBackendServersNode)
 	{
 		BackendServer backendServersObject;
+		if(!valueBackendServersBackendServer["Type"].isNull())
+			backendServersObject.type = valueBackendServersBackendServer["Type"].asString();
+		if(!valueBackendServersBackendServer["VpcId"].isNull())
+			backendServersObject.vpcId = valueBackendServersBackendServer["VpcId"].asString();
 		if(!valueBackendServersBackendServer["Weight"].isNull())
 			backendServersObject.weight = std::stoi(valueBackendServersBackendServer["Weight"].asString());
+		if(!valueBackendServersBackendServer["Description"].isNull())
+			backendServersObject.description = valueBackendServersBackendServer["Description"].asString();
+		if(!valueBackendServersBackendServer["ServerIp"].isNull())
+			backendServersObject.serverIp = valueBackendServersBackendServer["ServerIp"].asString();
 		if(!valueBackendServersBackendServer["ServerId"].isNull())
 			backendServersObject.serverId = valueBackendServersBackendServer["ServerId"].asString();
 		backendServers_.push_back(backendServersObject);
 	}
+	auto allLabels = value["Labels"]["Label"];
+	for (const auto &item : allLabels)
+		labels_.push_back(item.asString());
 	auto allListenerPorts = value["ListenerPorts"]["ListenerPort"];
 	for (const auto &item : allListenerPorts)
 		listenerPorts_.push_back(item.asString());
@@ -76,46 +103,96 @@ void DescribeLoadBalancerAttributeResult::parse(const std::string &payload)
 		vpcId_ = value["VpcId"].asString();
 	if(!value["CreateTimeStamp"].isNull())
 		createTimeStamp_ = std::stol(value["CreateTimeStamp"].asString());
-	if(!value["LoadBalancerSpec"].isNull())
-		loadBalancerSpec_ = value["LoadBalancerSpec"].asString();
-	if(!value["AutoReleaseTime"].isNull())
-		autoReleaseTime_ = std::stol(value["AutoReleaseTime"].asString());
-	if(!value["IsPublicAddress"].isNull())
-		isPublicAddress_ = value["IsPublicAddress"].asString();
+	if(!value["ReservedInfoBandwidth"].isNull())
+		reservedInfoBandwidth_ = value["ReservedInfoBandwidth"].asString();
+	if(!value["CloudInstanceId"].isNull())
+		cloudInstanceId_ = value["CloudInstanceId"].asString();
+	if(!value["HasReservedInfo"].isNull())
+		hasReservedInfo_ = value["HasReservedInfo"].asString();
 	if(!value["CreateTime"].isNull())
 		createTime_ = value["CreateTime"].asString();
 	if(!value["LoadBalancerId"].isNull())
 		loadBalancerId_ = value["LoadBalancerId"].asString();
+	if(!value["TunnelType"].isNull())
+		tunnelType_ = value["TunnelType"].asString();
 	if(!value["PayType"].isNull())
 		payType_ = value["PayType"].asString();
+	if(!value["ReservedInfoOrderType"].isNull())
+		reservedInfoOrderType_ = value["ReservedInfoOrderType"].asString();
 	if(!value["AddressType"].isNull())
 		addressType_ = value["AddressType"].asString();
+	if(!value["SupportPrivateLink"].isNull())
+		supportPrivateLink_ = value["SupportPrivateLink"].asString() == "true";
 	if(!value["NetworkType"].isNull())
 		networkType_ = value["NetworkType"].asString();
+	if(!value["ServiceManagedMode"].isNull())
+		serviceManagedMode_ = value["ServiceManagedMode"].asString();
+	if(!value["SpecBpsFlag"].isNull())
+		specBpsFlag_ = value["SpecBpsFlag"].asString() == "true";
+	if(!value["AddressIPVersion"].isNull())
+		addressIPVersion_ = value["AddressIPVersion"].asString();
+	if(!value["RenewalCycUnit"].isNull())
+		renewalCycUnit_ = value["RenewalCycUnit"].asString();
+	if(!value["Bandwidth"].isNull())
+		bandwidth_ = std::stoi(value["Bandwidth"].asString());
+	if(!value["LoadBalancerName"].isNull())
+		loadBalancerName_ = value["LoadBalancerName"].asString();
+	if(!value["Address"].isNull())
+		address_ = value["Address"].asString();
+	if(!value["AssociatedCenStatus"].isNull())
+		associatedCenStatus_ = value["AssociatedCenStatus"].asString();
+	if(!value["SlaveZoneId"].isNull())
+		slaveZoneId_ = value["SlaveZoneId"].asString();
+	if(!value["CloudInstanceType"].isNull())
+		cloudInstanceType_ = value["CloudInstanceType"].asString();
+	if(!value["EndTimeStamp"].isNull())
+		endTimeStamp_ = std::stol(value["EndTimeStamp"].asString());
+	if(!value["ReservedInfoActiveTime"].isNull())
+		reservedInfoActiveTime_ = value["ReservedInfoActiveTime"].asString();
+	if(!value["MasterZoneId"].isNull())
+		masterZoneId_ = value["MasterZoneId"].asString();
+	if(!value["ReservedInfoInternetChargeType"].isNull())
+		reservedInfoInternetChargeType_ = value["ReservedInfoInternetChargeType"].asString();
+	if(!value["LoadBalancerSpec"].isNull())
+		loadBalancerSpec_ = value["LoadBalancerSpec"].asString();
+	if(!value["SpecType"].isNull())
+		specType_ = value["SpecType"].asString();
+	if(!value["CloudType"].isNull())
+		cloudType_ = value["CloudType"].asString();
+	if(!value["AutoReleaseTime"].isNull())
+		autoReleaseTime_ = std::stol(value["AutoReleaseTime"].asString());
+	if(!value["ModificationProtectionReason"].isNull())
+		modificationProtectionReason_ = value["ModificationProtectionReason"].asString();
 	if(!value["RegionId"].isNull())
 		regionId_ = value["RegionId"].asString();
+	if(!value["ModificationProtectionStatus"].isNull())
+		modificationProtectionStatus_ = value["ModificationProtectionStatus"].asString();
 	if(!value["EndTime"].isNull())
 		endTime_ = value["EndTime"].asString();
 	if(!value["VSwitchId"].isNull())
 		vSwitchId_ = value["VSwitchId"].asString();
-	if(!value["Bandwidth"].isNull())
-		bandwidth_ = std::stoi(value["Bandwidth"].asString());
 	if(!value["LoadBalancerStatus"].isNull())
 		loadBalancerStatus_ = value["LoadBalancerStatus"].asString();
-	if(!value["LoadBalancerName"].isNull())
-		loadBalancerName_ = value["LoadBalancerName"].asString();
+	if(!value["ResourceGroupId"].isNull())
+		resourceGroupId_ = value["ResourceGroupId"].asString();
 	if(!value["InternetChargeType"].isNull())
 		internetChargeType_ = value["InternetChargeType"].asString();
-	if(!value["Address"].isNull())
-		address_ = value["Address"].asString();
-	if(!value["SlaveZoneId"].isNull())
-		slaveZoneId_ = value["SlaveZoneId"].asString();
-	if(!value["EndTimeStamp"].isNull())
-		endTimeStamp_ = std::stol(value["EndTimeStamp"].asString());
+	if(!value["BusinessStatus"].isNull())
+		businessStatus_ = value["BusinessStatus"].asString();
+	if(!value["AssociatedCenId"].isNull())
+		associatedCenId_ = value["AssociatedCenId"].asString();
+	if(!value["DeleteProtection"].isNull())
+		deleteProtection_ = value["DeleteProtection"].asString();
 	if(!value["RegionIdAlias"].isNull())
 		regionIdAlias_ = value["RegionIdAlias"].asString();
-	if(!value["MasterZoneId"].isNull())
-		masterZoneId_ = value["MasterZoneId"].asString();
+	if(!value["RenewalStatus"].isNull())
+		renewalStatus_ = value["RenewalStatus"].asString();
+	if(!value["RenewalDuration"].isNull())
+		renewalDuration_ = std::stoi(value["RenewalDuration"].asString());
+	if(!value["CloudInstanceUid"].isNull())
+		cloudInstanceUid_ = std::stol(value["CloudInstanceUid"].asString());
+	if(!value["InstanceChargeType"].isNull())
+		instanceChargeType_ = value["InstanceChargeType"].asString();
 
 }
 
@@ -124,14 +201,154 @@ std::vector<DescribeLoadBalancerAttributeResult::ListenerPortAndProtocal> Descri
 	return listenerPortsAndProtocal_;
 }
 
+std::string DescribeLoadBalancerAttributeResult::getAddress()const
+{
+	return address_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getSpecType()const
+{
+	return specType_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getInstanceChargeType()const
+{
+	return instanceChargeType_;
+}
+
+std::vector<DescribeLoadBalancerAttributeResult::BackendServer> DescribeLoadBalancerAttributeResult::getBackendServers()const
+{
+	return backendServers_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getHasReservedInfo()const
+{
+	return hasReservedInfo_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getBusinessStatus()const
+{
+	return businessStatus_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getLoadBalancerSpec()const
+{
+	return loadBalancerSpec_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getServiceManagedMode()const
+{
+	return serviceManagedMode_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getModificationProtectionReason()const
+{
+	return modificationProtectionReason_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getAssociatedCenId()const
+{
+	return associatedCenId_;
+}
+
+std::vector<DescribeLoadBalancerAttributeResult::Tag> DescribeLoadBalancerAttributeResult::getTags()const
+{
+	return tags_;
+}
+
+std::vector<std::string> DescribeLoadBalancerAttributeResult::getListenerPorts()const
+{
+	return listenerPorts_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getCloudInstanceType()const
+{
+	return cloudInstanceType_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getVSwitchId()const
+{
+	return vSwitchId_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getRenewalStatus()const
+{
+	return renewalStatus_;
+}
+
+std::vector<std::string> DescribeLoadBalancerAttributeResult::getLabels()const
+{
+	return labels_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getPayType()const
+{
+	return payType_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getInternetChargeType()const
+{
+	return internetChargeType_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getReservedInfoInternetChargeType()const
+{
+	return reservedInfoInternetChargeType_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getVpcId()const
+{
+	return vpcId_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getDeleteProtection()const
+{
+	return deleteProtection_;
+}
+
+long DescribeLoadBalancerAttributeResult::getEndTimeStamp()const
+{
+	return endTimeStamp_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getLoadBalancerStatus()const
+{
+	return loadBalancerStatus_;
+}
+
+long DescribeLoadBalancerAttributeResult::getAutoReleaseTime()const
+{
+	return autoReleaseTime_;
+}
+
+int DescribeLoadBalancerAttributeResult::getRenewalDuration()const
+{
+	return renewalDuration_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getAssociatedCenStatus()const
+{
+	return associatedCenStatus_;
+}
+
 std::string DescribeLoadBalancerAttributeResult::getEndTime()const
 {
 	return endTime_;
 }
 
-std::string DescribeLoadBalancerAttributeResult::getAddress()const
+bool DescribeLoadBalancerAttributeResult::getSupportPrivateLink()const
 {
-	return address_;
+	return supportPrivateLink_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getAddressIPVersion()const
+{
+	return addressIPVersion_;
 }
 
 std::vector<DescribeLoadBalancerAttributeResult::ListenerPortAndProtocol> DescribeLoadBalancerAttributeResult::getListenerPortsAndProtocol()const
@@ -144,14 +361,14 @@ std::string DescribeLoadBalancerAttributeResult::getLoadBalancerId()const
 	return loadBalancerId_;
 }
 
-std::vector<DescribeLoadBalancerAttributeResult::BackendServer> DescribeLoadBalancerAttributeResult::getBackendServers()const
+std::string DescribeLoadBalancerAttributeResult::getReservedInfoBandwidth()const
 {
-	return backendServers_;
+	return reservedInfoBandwidth_;
 }
 
-std::string DescribeLoadBalancerAttributeResult::getLoadBalancerSpec()const
+std::string DescribeLoadBalancerAttributeResult::getModificationProtectionStatus()const
 {
-	return loadBalancerSpec_;
+	return modificationProtectionStatus_;
 }
 
 std::string DescribeLoadBalancerAttributeResult::getNetworkType()const
@@ -164,9 +381,9 @@ int DescribeLoadBalancerAttributeResult::getBandwidth()const
 	return bandwidth_;
 }
 
-std::vector<std::string> DescribeLoadBalancerAttributeResult::getListenerPorts()const
+bool DescribeLoadBalancerAttributeResult::getSpecBpsFlag()const
 {
-	return listenerPorts_;
+	return specBpsFlag_;
 }
 
 std::string DescribeLoadBalancerAttributeResult::getMasterZoneId()const
@@ -174,19 +391,39 @@ std::string DescribeLoadBalancerAttributeResult::getMasterZoneId()const
 	return masterZoneId_;
 }
 
+std::string DescribeLoadBalancerAttributeResult::getTunnelType()const
+{
+	return tunnelType_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getCloudType()const
+{
+	return cloudType_;
+}
+
 std::string DescribeLoadBalancerAttributeResult::getCreateTime()const
 {
 	return createTime_;
 }
 
-std::string DescribeLoadBalancerAttributeResult::getVSwitchId()const
+long DescribeLoadBalancerAttributeResult::getCloudInstanceUid()const
 {
-	return vSwitchId_;
+	return cloudInstanceUid_;
 }
 
-std::string DescribeLoadBalancerAttributeResult::getPayType()const
+std::string DescribeLoadBalancerAttributeResult::getRenewalCycUnit()const
 {
-	return payType_;
+	return renewalCycUnit_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getReservedInfoActiveTime()const
+{
+	return reservedInfoActiveTime_;
+}
+
+std::string DescribeLoadBalancerAttributeResult::getCloudInstanceId()const
+{
+	return cloudInstanceId_;
 }
 
 std::string DescribeLoadBalancerAttributeResult::getSlaveZoneId()const
@@ -194,11 +431,6 @@ std::string DescribeLoadBalancerAttributeResult::getSlaveZoneId()const
 	return slaveZoneId_;
 }
 
-std::string DescribeLoadBalancerAttributeResult::getInternetChargeType()const
-{
-	return internetChargeType_;
-}
-
 std::string DescribeLoadBalancerAttributeResult::getRegionIdAlias()const
 {
 	return regionIdAlias_;
@@ -209,19 +441,9 @@ std::string DescribeLoadBalancerAttributeResult::getLoadBalancerName()const
 	return loadBalancerName_;
 }
 
-std::string DescribeLoadBalancerAttributeResult::getIsPublicAddress()const
+std::string DescribeLoadBalancerAttributeResult::getReservedInfoOrderType()const
 {
-	return isPublicAddress_;
-}
-
-std::string DescribeLoadBalancerAttributeResult::getVpcId()const
-{
-	return vpcId_;
-}
-
-long DescribeLoadBalancerAttributeResult::getEndTimeStamp()const
-{
-	return endTimeStamp_;
+	return reservedInfoOrderType_;
 }
 
 std::string DescribeLoadBalancerAttributeResult::getRegionId()const
@@ -234,18 +456,8 @@ 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/DescribeLoadBalancerHTTPListenerAttributeRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::Slb::Model::DescribeLoadBalancerHTTPListenerAttributeRequest;
 
 DescribeLoadBalancerHTTPListenerAttributeRequest::DescribeLoadBalancerHTTPListenerAttributeRequest()
-    : RpcServiceRequest("slb", "2013-02-21", "DescribeLoadBalancerHTTPListenerAttribute") {
+    : RpcServiceRequest("slb", "2014-05-15", "DescribeLoadBalancerHTTPListenerAttribute") {
   setMethod(HttpRequest::Method::Post);
 }
 
@@ -43,13 +43,13 @@ void DescribeLoadBalancerHTTPListenerAttributeRequest::setResourceOwnerId(long r
   setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-std::string DescribeLoadBalancerHTTPListenerAttributeRequest::getAccessKeyId() const {
-  return accessKeyId_;
+std::string DescribeLoadBalancerHTTPListenerAttributeRequest::getRegionId() const {
+  return regionId_;
 }
 
-void DescribeLoadBalancerHTTPListenerAttributeRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
+void DescribeLoadBalancerHTTPListenerAttributeRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
 int DescribeLoadBalancerHTTPListenerAttributeRequest::getListenerPort() const {

slb/src/model/DescribeLoadBalancerHTTPListenerAttributeResult.cc

@@ -39,48 +39,107 @@ void DescribeLoadBalancerHTTPListenerAttributeResult::parse(const std::string &p
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["Status"].isNull())
-		status_ = value["Status"].asString();
+	auto allRulesNode = value["Rules"]["Rule"];
+	for (auto valueRulesRule : allRulesNode)
+	{
+		Rule rulesObject;
+		if(!valueRulesRule["VServerGroupId"].isNull())
+			rulesObject.vServerGroupId = valueRulesRule["VServerGroupId"].asString();
+		if(!valueRulesRule["Url"].isNull())
+			rulesObject.url = valueRulesRule["Url"].asString();
+		if(!valueRulesRule["Domain"].isNull())
+			rulesObject.domain = valueRulesRule["Domain"].asString();
+		if(!valueRulesRule["RuleName"].isNull())
+			rulesObject.ruleName = valueRulesRule["RuleName"].asString();
+		if(!valueRulesRule["RuleId"].isNull())
+			rulesObject.ruleId = valueRulesRule["RuleId"].asString();
+		rules_.push_back(rulesObject);
+	}
+	auto allTagsNode = value["Tags"]["Tag"];
+	for (auto valueTagsTag : allTagsNode)
+	{
+		Tag tagsObject;
+		if(!valueTagsTag["TagKey"].isNull())
+			tagsObject.tagKey = valueTagsTag["TagKey"].asString();
+		if(!valueTagsTag["TagValue"].isNull())
+			tagsObject.tagValue = valueTagsTag["TagValue"].asString();
+		tags_.push_back(tagsObject);
+	}
+	auto allAclIds = value["AclIds"]["AclId"];
+	for (const auto &item : allAclIds)
+		aclIds_.push_back(item.asString());
+	if(!value["AclType"].isNull())
+		aclType_ = value["AclType"].asString();
 	if(!value["VServerGroupId"].isNull())
 		vServerGroupId_ = value["VServerGroupId"].asString();
+	if(!value["HealthCheckHttpVersion"].isNull())
+		healthCheckHttpVersion_ = value["HealthCheckHttpVersion"].asString();
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["XForwardedFor_ClientSrcPort"].isNull())
+		xForwardedFor_ClientSrcPort_ = value["XForwardedFor_ClientSrcPort"].asString();
 	if(!value["Cookie"].isNull())
 		cookie_ = value["Cookie"].asString();
 	if(!value["Gzip"].isNull())
 		gzip_ = value["Gzip"].asString();
+	if(!value["ForwardCode"].isNull())
+		forwardCode_ = std::stoi(value["ForwardCode"].asString());
+	if(!value["ServiceManagedMode"].isNull())
+		serviceManagedMode_ = value["ServiceManagedMode"].asString();
 	if(!value["HealthCheckConnectPort"].isNull())
 		healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
 	if(!value["Bandwidth"].isNull())
 		bandwidth_ = std::stoi(value["Bandwidth"].asString());
 	if(!value["HealthCheckTimeout"].isNull())
 		healthCheckTimeout_ = std::stoi(value["HealthCheckTimeout"].asString());
+	if(!value["HealthCheckType"].isNull())
+		healthCheckType_ = value["HealthCheckType"].asString();
+	if(!value["AclStatus"].isNull())
+		aclStatus_ = value["AclStatus"].asString();
 	if(!value["BackendServerPort"].isNull())
 		backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
 	if(!value["CookieTimeout"].isNull())
 		cookieTimeout_ = std::stoi(value["CookieTimeout"].asString());
-	if(!value["URI"].isNull())
-		uRI_ = value["URI"].asString();
+	if(!value["HealthCheckDomain"].isNull())
+		healthCheckDomain_ = value["HealthCheckDomain"].asString();
 	if(!value["UnhealthyThreshold"].isNull())
 		unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
+	if(!value["ForwardPort"].isNull())
+		forwardPort_ = std::stoi(value["ForwardPort"].asString());
 	if(!value["XForwardedFor_SLBID"].isNull())
 		xForwardedFor_SLBID_ = value["XForwardedFor_SLBID"].asString();
 	if(!value["SecurityStatus"].isNull())
 		securityStatus_ = value["SecurityStatus"].asString();
 	if(!value["HealthCheckHttpCode"].isNull())
 		healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
-	if(!value["Domain"].isNull())
-		domain_ = value["Domain"].asString();
 	if(!value["MaxConnection"].isNull())
 		maxConnection_ = std::stoi(value["MaxConnection"].asString());
+	if(!value["ListenerForward"].isNull())
+		listenerForward_ = value["ListenerForward"].asString();
 	if(!value["XForwardedFor"].isNull())
 		xForwardedFor_ = value["XForwardedFor"].asString();
+	if(!value["IdleTimeout"].isNull())
+		idleTimeout_ = std::stoi(value["IdleTimeout"].asString());
+	if(!value["RequestTimeout"].isNull())
+		requestTimeout_ = std::stoi(value["RequestTimeout"].asString());
 	if(!value["ListenerPort"].isNull())
 		listenerPort_ = std::stoi(value["ListenerPort"].asString());
+	if(!value["HealthCheckInterval"].isNull())
+		healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
+	if(!value["XForwardedFor_SLBPORT"].isNull())
+		xForwardedFor_SLBPORT_ = value["XForwardedFor_SLBPORT"].asString();
+	if(!value["HealthCheckURI"].isNull())
+		healthCheckURI_ = value["HealthCheckURI"].asString();
 	if(!value["StickySessionType"].isNull())
 		stickySessionType_ = value["StickySessionType"].asString();
+	if(!value["AclId"].isNull())
+		aclId_ = value["AclId"].asString();
 	if(!value["Scheduler"].isNull())
 		scheduler_ = value["Scheduler"].asString();
-	if(!value["Interval"].isNull())
-		interval_ = std::stoi(value["Interval"].asString());
+	if(!value["VpcIds"].isNull())
+		vpcIds_ = value["VpcIds"].asString();
 	if(!value["HealthyThreshold"].isNull())
 		healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
 	if(!value["XForwardedFor_proto"].isNull())
@@ -89,8 +148,12 @@ void DescribeLoadBalancerHTTPListenerAttributeResult::parse(const std::string &p
 		xForwardedFor_SLBIP_ = value["XForwardedFor_SLBIP"].asString();
 	if(!value["StickySession"].isNull())
 		stickySession_ = value["StickySession"].asString();
+	if(!value["HealthCheckMethod"].isNull())
+		healthCheckMethod_ = value["HealthCheckMethod"].asString();
 	if(!value["HealthCheck"].isNull())
 		healthCheck_ = value["HealthCheck"].asString();
+	if(!value["LoadBalancerId"].isNull())
+		loadBalancerId_ = value["LoadBalancerId"].asString();
 
 }
 
@@ -109,11 +172,21 @@ std::string DescribeLoadBalancerHTTPListenerAttributeResult::getVServerGroupId()
 	return vServerGroupId_;
 }
 
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getDescription()const
+{
+	return description_;
+}
+
 int DescribeLoadBalancerHTTPListenerAttributeResult::getUnhealthyThreshold()const
 {
 	return unhealthyThreshold_;
 }
 
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckURI()const
+{
+	return healthCheckURI_;
+}
+
 std::string DescribeLoadBalancerHTTPListenerAttributeResult::getScheduler()const
 {
 	return scheduler_;
@@ -124,16 +197,21 @@ std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheck()con
 	return healthCheck_;
 }
 
+int DescribeLoadBalancerHTTPListenerAttributeResult::getIdleTimeout()const
+{
+	return idleTimeout_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getLoadBalancerId()const
+{
+	return loadBalancerId_;
+}
+
 int DescribeLoadBalancerHTTPListenerAttributeResult::getBackendServerPort()const
 {
 	return backendServerPort_;
 }
 
-std::string DescribeLoadBalancerHTTPListenerAttributeResult::getURI()const
-{
-	return uRI_;
-}
-
 std::string DescribeLoadBalancerHTTPListenerAttributeResult::getXForwardedFor_SLBID()const
 {
 	return xForwardedFor_SLBID_;
@@ -144,6 +222,21 @@ int DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckConnectPort()
 	return healthCheckConnectPort_;
 }
 
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getXForwardedFor_SLBPORT()const
+{
+	return xForwardedFor_SLBPORT_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckMethod()const
+{
+	return healthCheckMethod_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getServiceManagedMode()const
+{
+	return serviceManagedMode_;
+}
+
 int DescribeLoadBalancerHTTPListenerAttributeResult::getBandwidth()const
 {
 	return bandwidth_;
@@ -174,6 +267,16 @@ std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckHttpC
 	return healthCheckHttpCode_;
 }
 
+std::vector<DescribeLoadBalancerHTTPListenerAttributeResult::Tag> DescribeLoadBalancerHTTPListenerAttributeResult::getTags()const
+{
+	return tags_;
+}
+
+int DescribeLoadBalancerHTTPListenerAttributeResult::getForwardCode()const
+{
+	return forwardCode_;
+}
+
 std::string DescribeLoadBalancerHTTPListenerAttributeResult::getStatus()const
 {
 	return status_;
@@ -184,43 +287,103 @@ std::string DescribeLoadBalancerHTTPListenerAttributeResult::getCookie()const
 	return cookie_;
 }
 
+int DescribeLoadBalancerHTTPListenerAttributeResult::getRequestTimeout()const
+{
+	return requestTimeout_;
+}
+
 int DescribeLoadBalancerHTTPListenerAttributeResult::getListenerPort()const
 {
 	return listenerPort_;
 }
 
+int DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckInterval()const
+{
+	return healthCheckInterval_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getAclId()const
+{
+	return aclId_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckHttpVersion()const
+{
+	return healthCheckHttpVersion_;
+}
+
 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_ClientSrcPort()const
+{
+	return xForwardedFor_ClientSrcPort_;
+}
+
 std::string DescribeLoadBalancerHTTPListenerAttributeResult::getXForwardedFor()const
 {
 	return xForwardedFor_;
 }
 
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckDomain()const
+{
+	return healthCheckDomain_;
+}
+
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getAclType()const
+{
+	return aclType_;
+}
+
 std::string DescribeLoadBalancerHTTPListenerAttributeResult::getXForwardedFor_proto()const
 {
 	return xForwardedFor_proto_;
 }
 
-std::string DescribeLoadBalancerHTTPListenerAttributeResult::getDomain()const
+std::vector<std::string> DescribeLoadBalancerHTTPListenerAttributeResult::getAclIds()const
 {
-	return domain_;
+	return aclIds_;
 }
 
-int DescribeLoadBalancerHTTPListenerAttributeResult::getInterval()const
+std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckType()const
 {
-	return interval_;
+	return healthCheckType_;
 }
 

slb/src/model/DescribeLoadBalancerHTTPSListenerAttributeRequest.cc

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

slb/src/model/DescribeLoadBalancerHTTPSListenerAttributeResult.cc

@@ -0,0 +1,519 @@
+/*
+ * 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/DescribeLoadBalancerHTTPSListenerAttributeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DescribeLoadBalancerHTTPSListenerAttributeResult::DescribeLoadBalancerHTTPSListenerAttributeResult() :
+	ServiceResult()
+{}
+
+DescribeLoadBalancerHTTPSListenerAttributeResult::DescribeLoadBalancerHTTPSListenerAttributeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLoadBalancerHTTPSListenerAttributeResult::~DescribeLoadBalancerHTTPSListenerAttributeResult()
+{}
+
+void DescribeLoadBalancerHTTPSListenerAttributeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allRulesNode = value["Rules"]["Rule"];
+	for (auto valueRulesRule : allRulesNode)
+	{
+		Rule rulesObject;
+		if(!valueRulesRule["VServerGroupId"].isNull())
+			rulesObject.vServerGroupId = valueRulesRule["VServerGroupId"].asString();
+		if(!valueRulesRule["Url"].isNull())
+			rulesObject.url = valueRulesRule["Url"].asString();
+		if(!valueRulesRule["Domain"].isNull())
+			rulesObject.domain = valueRulesRule["Domain"].asString();
+		if(!valueRulesRule["RuleName"].isNull())
+			rulesObject.ruleName = valueRulesRule["RuleName"].asString();
+		if(!valueRulesRule["RuleId"].isNull())
+			rulesObject.ruleId = valueRulesRule["RuleId"].asString();
+		rules_.push_back(rulesObject);
+	}
+	auto allDomainExtensionsNode = value["DomainExtensions"]["DomainExtension"];
+	for (auto valueDomainExtensionsDomainExtension : allDomainExtensionsNode)
+	{
+		DomainExtension domainExtensionsObject;
+		if(!valueDomainExtensionsDomainExtension["ServerCertificateId"].isNull())
+			domainExtensionsObject.serverCertificateId = valueDomainExtensionsDomainExtension["ServerCertificateId"].asString();
+		if(!valueDomainExtensionsDomainExtension["Domain"].isNull())
+			domainExtensionsObject.domain = valueDomainExtensionsDomainExtension["Domain"].asString();
+		if(!valueDomainExtensionsDomainExtension["DomainExtensionId"].isNull())
+			domainExtensionsObject.domainExtensionId = valueDomainExtensionsDomainExtension["DomainExtensionId"].asString();
+		auto allCertificatesNode = valueDomainExtensionsDomainExtension["Certificates"]["Certificate"];
+		for (auto valueDomainExtensionsDomainExtensionCertificatesCertificate : allCertificatesNode)
+		{
+			DomainExtension::Certificate certificatesObject;
+			if(!valueDomainExtensionsDomainExtensionCertificatesCertificate["EncryptionAlgorithm"].isNull())
+				certificatesObject.encryptionAlgorithm = valueDomainExtensionsDomainExtensionCertificatesCertificate["EncryptionAlgorithm"].asString();
+			if(!valueDomainExtensionsDomainExtensionCertificatesCertificate["CertificateId"].isNull())
+				certificatesObject.certificateId = valueDomainExtensionsDomainExtensionCertificatesCertificate["CertificateId"].asString();
+			domainExtensionsObject.certificates.push_back(certificatesObject);
+		}
+		auto allServerCertificates1Node = valueDomainExtensionsDomainExtension["ServerCertificates"]["ServerCertificate"];
+		for (auto valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate : allServerCertificates1Node)
+		{
+			DomainExtension::ServerCertificate serverCertificates1Object;
+			if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
+				serverCertificates1Object.encryptionAlgorithm = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
+			if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["StandardType"].isNull())
+				serverCertificates1Object.standardType = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["StandardType"].asString();
+			if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["BindingType"].isNull())
+				serverCertificates1Object.bindingType = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["BindingType"].asString();
+			if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["CertificateId"].isNull())
+				serverCertificates1Object.certificateId = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["CertificateId"].asString();
+			domainExtensionsObject.serverCertificates1.push_back(serverCertificates1Object);
+		}
+		domainExtensions_.push_back(domainExtensionsObject);
+	}
+	auto allServerCertificatesNode = value["ServerCertificates"]["ServerCertificate"];
+	for (auto valueServerCertificatesServerCertificate : allServerCertificatesNode)
+	{
+		ServerCertificate2 serverCertificatesObject;
+		if(!valueServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
+			serverCertificatesObject.encryptionAlgorithm = valueServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
+		if(!valueServerCertificatesServerCertificate["StandardType"].isNull())
+			serverCertificatesObject.standardType = valueServerCertificatesServerCertificate["StandardType"].asString();
+		if(!valueServerCertificatesServerCertificate["BindingType"].isNull())
+			serverCertificatesObject.bindingType = valueServerCertificatesServerCertificate["BindingType"].asString();
+		if(!valueServerCertificatesServerCertificate["CertificateId"].isNull())
+			serverCertificatesObject.certificateId = valueServerCertificatesServerCertificate["CertificateId"].asString();
+		serverCertificates_.push_back(serverCertificatesObject);
+	}
+	auto allTagsNode = value["Tags"]["Tag"];
+	for (auto valueTagsTag : allTagsNode)
+	{
+		Tag tagsObject;
+		if(!valueTagsTag["TagKey"].isNull())
+			tagsObject.tagKey = valueTagsTag["TagKey"].asString();
+		if(!valueTagsTag["TagValue"].isNull())
+			tagsObject.tagValue = valueTagsTag["TagValue"].asString();
+		tags_.push_back(tagsObject);
+	}
+	auto allAclIds = value["AclIds"]["AclId"];
+	for (const auto &item : allAclIds)
+		aclIds_.push_back(item.asString());
+	if(!value["AclType"].isNull())
+		aclType_ = value["AclType"].asString();
+	if(!value["XForwardedFor_ClientCertClientVerify"].isNull())
+		xForwardedFor_ClientCertClientVerify_ = value["XForwardedFor_ClientCertClientVerify"].asString();
+	if(!value["CACertificateId"].isNull())
+		cACertificateId_ = value["CACertificateId"].asString();
+	if(!value["XForwardedFor_ClientCertClientVerifyAlias"].isNull())
+		xForwardedFor_ClientCertClientVerifyAlias_ = value["XForwardedFor_ClientCertClientVerifyAlias"].asString();
+	if(!value["HealthCheckConnectPort"].isNull())
+		healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
+	if(!value["BackendProtocol"].isNull())
+		backendProtocol_ = value["BackendProtocol"].asString();
+	if(!value["HealthCheckType"].isNull())
+		healthCheckType_ = value["HealthCheckType"].asString();
+	if(!value["BackendServerPort"].isNull())
+		backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
+	if(!value["CookieTimeout"].isNull())
+		cookieTimeout_ = std::stoi(value["CookieTimeout"].asString());
+	if(!value["HealthCheckDomain"].isNull())
+		healthCheckDomain_ = value["HealthCheckDomain"].asString();
+	if(!value["XForwardedFor_ClientCertFingerprintAlias"].isNull())
+		xForwardedFor_ClientCertFingerprintAlias_ = value["XForwardedFor_ClientCertFingerprintAlias"].asString();
+	if(!value["XForwardedFor_ClientCertIssuerDNAlias"].isNull())
+		xForwardedFor_ClientCertIssuerDNAlias_ = value["XForwardedFor_ClientCertIssuerDNAlias"].asString();
+	if(!value["XForwardedFor"].isNull())
+		xForwardedFor_ = value["XForwardedFor"].asString();
+	if(!value["XForwardedFor_ClientCertFingerprint"].isNull())
+		xForwardedFor_ClientCertFingerprint_ = value["XForwardedFor_ClientCertFingerprint"].asString();
+	if(!value["IdleTimeout"].isNull())
+		idleTimeout_ = std::stoi(value["IdleTimeout"].asString());
+	if(!value["ListenerPort"].isNull())
+		listenerPort_ = std::stoi(value["ListenerPort"].asString());
+	if(!value["HealthCheckURI"].isNull())
+		healthCheckURI_ = value["HealthCheckURI"].asString();
+	if(!value["XForwardedFor_SLBPORT"].isNull())
+		xForwardedFor_SLBPORT_ = value["XForwardedFor_SLBPORT"].asString();
+	if(!value["StickySessionType"].isNull())
+		stickySessionType_ = value["StickySessionType"].asString();
+	if(!value["Scheduler"].isNull())
+		scheduler_ = value["Scheduler"].asString();
+	if(!value["XForwardedFor_proto"].isNull())
+		xForwardedFor_proto_ = value["XForwardedFor_proto"].asString();
+	if(!value["HealthCheckMethod"].isNull())
+		healthCheckMethod_ = value["HealthCheckMethod"].asString();
+	if(!value["TLSCipherPolicy"].isNull())
+		tLSCipherPolicy_ = value["TLSCipherPolicy"].asString();
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["HealthCheckHttpVersion"].isNull())
+		healthCheckHttpVersion_ = value["HealthCheckHttpVersion"].asString();
+	if(!value["VServerGroupId"].isNull())
+		vServerGroupId_ = value["VServerGroupId"].asString();
+	if(!value["XForwardedFor_ClientSrcPort"].isNull())
+		xForwardedFor_ClientSrcPort_ = value["XForwardedFor_ClientSrcPort"].asString();
+	if(!value["Cookie"].isNull())
+		cookie_ = value["Cookie"].asString();
+	if(!value["Gzip"].isNull())
+		gzip_ = value["Gzip"].asString();
+	if(!value["EnableHttp2"].isNull())
+		enableHttp2_ = value["EnableHttp2"].asString();
+	if(!value["ServiceManagedMode"].isNull())
+		serviceManagedMode_ = value["ServiceManagedMode"].asString();
+	if(!value["Bandwidth"].isNull())
+		bandwidth_ = std::stoi(value["Bandwidth"].asString());
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
+	if(!value["HealthCheckTimeout"].isNull())
+		healthCheckTimeout_ = std::stoi(value["HealthCheckTimeout"].asString());
+	if(!value["AclStatus"].isNull())
+		aclStatus_ = value["AclStatus"].asString();
+	if(!value["UnhealthyThreshold"].isNull())
+		unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
+	if(!value["XForwardedFor_SLBID"].isNull())
+		xForwardedFor_SLBID_ = value["XForwardedFor_SLBID"].asString();
+	if(!value["XForwardedFor_ClientCertSubjectDN"].isNull())
+		xForwardedFor_ClientCertSubjectDN_ = value["XForwardedFor_ClientCertSubjectDN"].asString();
+	if(!value["SecurityStatus"].isNull())
+		securityStatus_ = value["SecurityStatus"].asString();
+	if(!value["HealthCheckHttpCode"].isNull())
+		healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
+	if(!value["XForwardedFor_ClientCertSubjectDNAlias"].isNull())
+		xForwardedFor_ClientCertSubjectDNAlias_ = value["XForwardedFor_ClientCertSubjectDNAlias"].asString();
+	if(!value["MaxConnection"].isNull())
+		maxConnection_ = std::stoi(value["MaxConnection"].asString());
+	if(!value["RequestTimeout"].isNull())
+		requestTimeout_ = std::stoi(value["RequestTimeout"].asString());
+	if(!value["HealthCheckInterval"].isNull())
+		healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
+	if(!value["ServerCertificateId"].isNull())
+		serverCertificateId_ = value["ServerCertificateId"].asString();
+	if(!value["AclId"].isNull())
+		aclId_ = value["AclId"].asString();
+	if(!value["XForwardedFor_ClientCertIssuerDN"].isNull())
+		xForwardedFor_ClientCertIssuerDN_ = value["XForwardedFor_ClientCertIssuerDN"].asString();
+	if(!value["VpcIds"].isNull())
+		vpcIds_ = value["VpcIds"].asString();
+	if(!value["HealthyThreshold"].isNull())
+		healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
+	if(!value["XForwardedFor_SLBIP"].isNull())
+		xForwardedFor_SLBIP_ = value["XForwardedFor_SLBIP"].asString();
+	if(!value["StickySession"].isNull())
+		stickySession_ = value["StickySession"].asString();
+	if(!value["HealthCheck"].isNull())
+		healthCheck_ = value["HealthCheck"].asString();
+	if(!value["LoadBalancerId"].isNull())
+		loadBalancerId_ = value["LoadBalancerId"].asString();
+
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getUnhealthyThreshold()const
+{
+	return unhealthyThreshold_;
+}
+
+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::getBackendServerPort()const
+{
+	return backendServerPort_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_SLBPORT()const
+{
+	return xForwardedFor_SLBPORT_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getServiceManagedMode()const
+{
+	return serviceManagedMode_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStickySessionType()const
+{
+	return stickySessionType_;
+}
+
+std::vector<DescribeLoadBalancerHTTPSListenerAttributeResult::Tag> DescribeLoadBalancerHTTPSListenerAttributeResult::getTags()const
+{
+	return tags_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_ClientCertSubjectDNAlias()const
+{
+	return xForwardedFor_ClientCertSubjectDNAlias_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStatus()const
+{
+	return status_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getCookie()const
+{
+	return cookie_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_ClientCertClientVerifyAlias()const
+{
+	return xForwardedFor_ClientCertClientVerifyAlias_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getRequestTimeout()const
+{
+	return requestTimeout_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getTLSCipherPolicy()const
+{
+	return tLSCipherPolicy_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckInterval()const
+{
+	return healthCheckInterval_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getCACertificateId()const
+{
+	return cACertificateId_;
+}
+
+std::vector<DescribeLoadBalancerHTTPSListenerAttributeResult::ServerCertificate2> DescribeLoadBalancerHTTPSListenerAttributeResult::getServerCertificates()const
+{
+	return serverCertificates_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_ClientCertFingerprintAlias()const
+{
+	return xForwardedFor_ClientCertFingerprintAlias_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckTimeout()const
+{
+	return healthCheckTimeout_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getAclStatus()const
+{
+	return aclStatus_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getVpcIds()const
+{
+	return vpcIds_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthyThreshold()const
+{
+	return healthyThreshold_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckDomain()const
+{
+	return healthCheckDomain_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getAclType()const
+{
+	return aclType_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_proto()const
+{
+	return xForwardedFor_proto_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getEnableHttp2()const
+{
+	return enableHttp2_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckType()const
+{
+	return healthCheckType_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getCookieTimeout()const
+{
+	return cookieTimeout_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getMaxConnection()const
+{
+	return maxConnection_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getVServerGroupId()const
+{
+	return vServerGroupId_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getBackendProtocol()const
+{
+	return backendProtocol_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getDescription()const
+{
+	return description_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getScheduler()const
+{
+	return scheduler_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getIdleTimeout()const
+{
+	return idleTimeout_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getLoadBalancerId()const
+{
+	return loadBalancerId_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_SLBID()const
+{
+	return xForwardedFor_SLBID_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckConnectPort()const
+{
+	return healthCheckConnectPort_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckMethod()const
+{
+	return healthCheckMethod_;
+}
+
+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::getXForwardedFor_SLBIP()const
+{
+	return xForwardedFor_SLBIP_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckHttpCode()const
+{
+	return healthCheckHttpCode_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getListenerPort()const
+{
+	return listenerPort_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_ClientCertSubjectDN()const
+{
+	return xForwardedFor_ClientCertSubjectDN_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getAclId()const
+{
+	return aclId_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_ClientCertIssuerDNAlias()const
+{
+	return xForwardedFor_ClientCertIssuerDNAlias_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckHttpVersion()const
+{
+	return healthCheckHttpVersion_;
+}
+
+std::vector<DescribeLoadBalancerHTTPSListenerAttributeResult::Rule> DescribeLoadBalancerHTTPSListenerAttributeResult::getRules()const
+{
+	return rules_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_ClientCertIssuerDN()const
+{
+	return xForwardedFor_ClientCertIssuerDN_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStickySession()const
+{
+	return stickySession_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor()const
+{
+	return xForwardedFor_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_ClientSrcPort()const
+{
+	return xForwardedFor_ClientSrcPort_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_ClientCertClientVerify()const
+{
+	return xForwardedFor_ClientCertClientVerify_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_ClientCertFingerprint()const
+{
+	return xForwardedFor_ClientCertFingerprint_;
+}
+
+std::vector<std::string> DescribeLoadBalancerHTTPSListenerAttributeResult::getAclIds()const
+{
+	return aclIds_;
+}
+

slb/src/model/DescribeLoadBalancerListenersRequest.cc

@@ -0,0 +1,139 @@
+/*
+ * 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/DescribeLoadBalancerListenersRequest.h>
+
+using AlibabaCloud::Slb::Model::DescribeLoadBalancerListenersRequest;
+
+DescribeLoadBalancerListenersRequest::DescribeLoadBalancerListenersRequest()
+    : RpcServiceRequest("slb", "2014-05-15", "DescribeLoadBalancerListeners") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeLoadBalancerListenersRequest::~DescribeLoadBalancerListenersRequest() {}
+
+long DescribeLoadBalancerListenersRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DescribeLoadBalancerListenersRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DescribeLoadBalancerListenersRequest::getDescription() const {
+  return description_;
+}
+
+void DescribeLoadBalancerListenersRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+std::string DescribeLoadBalancerListenersRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeLoadBalancerListenersRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeLoadBalancerListenersRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void DescribeLoadBalancerListenersRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::vector<DescribeLoadBalancerListenersRequest::Tag> DescribeLoadBalancerListenersRequest::getTag() const {
+  return tag_;
+}
+
+void DescribeLoadBalancerListenersRequest::setTag(const std::vector<DescribeLoadBalancerListenersRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
+int DescribeLoadBalancerListenersRequest::getListenerPort() const {
+  return listenerPort_;
+}
+
+void DescribeLoadBalancerListenersRequest::setListenerPort(int listenerPort) {
+  listenerPort_ = listenerPort;
+  setParameter(std::string("ListenerPort"), std::to_string(listenerPort));
+}
+
+std::string DescribeLoadBalancerListenersRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DescribeLoadBalancerListenersRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DescribeLoadBalancerListenersRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DescribeLoadBalancerListenersRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DescribeLoadBalancerListenersRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeLoadBalancerListenersRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DescribeLoadBalancerListenersRequest::getListenerProtocol() const {
+  return listenerProtocol_;
+}
+
+void DescribeLoadBalancerListenersRequest::setListenerProtocol(const std::string &listenerProtocol) {
+  listenerProtocol_ = listenerProtocol;
+  setParameter(std::string("ListenerProtocol"), listenerProtocol);
+}
+
+std::vector<std::string> DescribeLoadBalancerListenersRequest::getLoadBalancerId() const {
+  return loadBalancerId_;
+}
+
+void DescribeLoadBalancerListenersRequest::setLoadBalancerId(const std::vector<std::string> &loadBalancerId) {
+  loadBalancerId_ = loadBalancerId;
+}
+
+int DescribeLoadBalancerListenersRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void DescribeLoadBalancerListenersRequest::setMaxResults(int maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+

slb/src/model/DescribeLoadBalancerListenersResult.cc

@@ -0,0 +1,434 @@
+/*
+ * 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/DescribeLoadBalancerListenersResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DescribeLoadBalancerListenersResult::DescribeLoadBalancerListenersResult() :
+	ServiceResult()
+{}
+
+DescribeLoadBalancerListenersResult::DescribeLoadBalancerListenersResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLoadBalancerListenersResult::~DescribeLoadBalancerListenersResult()
+{}
+
+void DescribeLoadBalancerListenersResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allListenersNode = value["Listeners"]["Listener"];
+	for (auto valueListenersListener : allListenersNode)
+	{
+		Listener listenersObject;
+		if(!valueListenersListener["AclType"].isNull())
+			listenersObject.aclType = valueListenersListener["AclType"].asString();
+		if(!valueListenersListener["Status"].isNull())
+			listenersObject.status = valueListenersListener["Status"].asString();
+		if(!valueListenersListener["VServerGroupId"].isNull())
+			listenersObject.vServerGroupId = valueListenersListener["VServerGroupId"].asString();
+		if(!valueListenersListener["ListenerProtocol"].isNull())
+			listenersObject.listenerProtocol = valueListenersListener["ListenerProtocol"].asString();
+		if(!valueListenersListener["LoadBalancerId"].isNull())
+			listenersObject.loadBalancerId = valueListenersListener["LoadBalancerId"].asString();
+		if(!valueListenersListener["ListenerPort"].isNull())
+			listenersObject.listenerPort = std::stoi(valueListenersListener["ListenerPort"].asString());
+		if(!valueListenersListener["ServiceManagedMode"].isNull())
+			listenersObject.serviceManagedMode = valueListenersListener["ServiceManagedMode"].asString();
+		if(!valueListenersListener["AclId"].isNull())
+			listenersObject.aclId = valueListenersListener["AclId"].asString();
+		if(!valueListenersListener["Scheduler"].isNull())
+			listenersObject.scheduler = valueListenersListener["Scheduler"].asString();
+		if(!valueListenersListener["Bandwidth"].isNull())
+			listenersObject.bandwidth = std::stoi(valueListenersListener["Bandwidth"].asString());
+		if(!valueListenersListener["Description"].isNull())
+			listenersObject.description = valueListenersListener["Description"].asString();
+		if(!valueListenersListener["AclStatus"].isNull())
+			listenersObject.aclStatus = valueListenersListener["AclStatus"].asString();
+		if(!valueListenersListener["BackendServerPort"].isNull())
+			listenersObject.backendServerPort = std::stoi(valueListenersListener["BackendServerPort"].asString());
+		if(!valueListenersListener["BackendProtocol"].isNull())
+			listenersObject.backendProtocol = valueListenersListener["BackendProtocol"].asString();
+		auto allTagsNode = valueListenersListener["Tags"]["Tag"];
+		for (auto valueListenersListenerTagsTag : allTagsNode)
+		{
+			Listener::Tag tagsObject;
+			if(!valueListenersListenerTagsTag["TagValue"].isNull())
+				tagsObject.tagValue = valueListenersListenerTagsTag["TagValue"].asString();
+			if(!valueListenersListenerTagsTag["TagKey"].isNull())
+				tagsObject.tagKey = valueListenersListenerTagsTag["TagKey"].asString();
+			listenersObject.tags.push_back(tagsObject);
+		}
+		auto hTTPListenerConfigNode = value["HTTPListenerConfig"];
+		if(!hTTPListenerConfigNode["HealthCheckHttpVersion"].isNull())
+			listenersObject.hTTPListenerConfig.healthCheckHttpVersion = hTTPListenerConfigNode["HealthCheckHttpVersion"].asString();
+		if(!hTTPListenerConfigNode["XForwardedFor_ClientSrcPort"].isNull())
+			listenersObject.hTTPListenerConfig.xForwardedFor_ClientSrcPort = hTTPListenerConfigNode["XForwardedFor_ClientSrcPort"].asString();
+		if(!hTTPListenerConfigNode["Cookie"].isNull())
+			listenersObject.hTTPListenerConfig.cookie = hTTPListenerConfigNode["Cookie"].asString();
+		if(!hTTPListenerConfigNode["Gzip"].isNull())
+			listenersObject.hTTPListenerConfig.gzip = hTTPListenerConfigNode["Gzip"].asString();
+		if(!hTTPListenerConfigNode["ForwardCode"].isNull())
+			listenersObject.hTTPListenerConfig.forwardCode = std::stoi(hTTPListenerConfigNode["ForwardCode"].asString());
+		if(!hTTPListenerConfigNode["HealthCheckConnectPort"].isNull())
+			listenersObject.hTTPListenerConfig.healthCheckConnectPort = std::stoi(hTTPListenerConfigNode["HealthCheckConnectPort"].asString());
+		if(!hTTPListenerConfigNode["HealthCheckTimeout"].isNull())
+			listenersObject.hTTPListenerConfig.healthCheckTimeout = std::stoi(hTTPListenerConfigNode["HealthCheckTimeout"].asString());
+		if(!hTTPListenerConfigNode["HealthCheckType"].isNull())
+			listenersObject.hTTPListenerConfig.healthCheckType = hTTPListenerConfigNode["HealthCheckType"].asString();
+		if(!hTTPListenerConfigNode["CookieTimeout"].isNull())
+			listenersObject.hTTPListenerConfig.cookieTimeout = std::stoi(hTTPListenerConfigNode["CookieTimeout"].asString());
+		if(!hTTPListenerConfigNode["HealthCheckDomain"].isNull())
+			listenersObject.hTTPListenerConfig.healthCheckDomain = hTTPListenerConfigNode["HealthCheckDomain"].asString();
+		if(!hTTPListenerConfigNode["UnhealthyThreshold"].isNull())
+			listenersObject.hTTPListenerConfig.unhealthyThreshold = std::stoi(hTTPListenerConfigNode["UnhealthyThreshold"].asString());
+		if(!hTTPListenerConfigNode["XForwardedFor_SLBID"].isNull())
+			listenersObject.hTTPListenerConfig.xForwardedFor_SLBID = hTTPListenerConfigNode["XForwardedFor_SLBID"].asString();
+		if(!hTTPListenerConfigNode["ForwardPort"].isNull())
+			listenersObject.hTTPListenerConfig.forwardPort = std::stoi(hTTPListenerConfigNode["ForwardPort"].asString());
+		if(!hTTPListenerConfigNode["HealthCheckHttpCode"].isNull())
+			listenersObject.hTTPListenerConfig.healthCheckHttpCode = hTTPListenerConfigNode["HealthCheckHttpCode"].asString();
+		if(!hTTPListenerConfigNode["ListenerForward"].isNull())
+			listenersObject.hTTPListenerConfig.listenerForward = hTTPListenerConfigNode["ListenerForward"].asString();
+		if(!hTTPListenerConfigNode["XForwardedFor"].isNull())
+			listenersObject.hTTPListenerConfig.xForwardedFor = hTTPListenerConfigNode["XForwardedFor"].asString();
+		if(!hTTPListenerConfigNode["IdleTimeout"].isNull())
+			listenersObject.hTTPListenerConfig.idleTimeout = std::stoi(hTTPListenerConfigNode["IdleTimeout"].asString());
+		if(!hTTPListenerConfigNode["RequestTimeout"].isNull())
+			listenersObject.hTTPListenerConfig.requestTimeout = std::stoi(hTTPListenerConfigNode["RequestTimeout"].asString());
+		if(!hTTPListenerConfigNode["HealthCheckInterval"].isNull())
+			listenersObject.hTTPListenerConfig.healthCheckInterval = std::stoi(hTTPListenerConfigNode["HealthCheckInterval"].asString());
+		if(!hTTPListenerConfigNode["XForwardedFor_SLBPORT"].isNull())
+			listenersObject.hTTPListenerConfig.xForwardedFor_SLBPORT = hTTPListenerConfigNode["XForwardedFor_SLBPORT"].asString();
+		if(!hTTPListenerConfigNode["HealthCheckURI"].isNull())
+			listenersObject.hTTPListenerConfig.healthCheckURI = hTTPListenerConfigNode["HealthCheckURI"].asString();
+		if(!hTTPListenerConfigNode["StickySessionType"].isNull())
+			listenersObject.hTTPListenerConfig.stickySessionType = hTTPListenerConfigNode["StickySessionType"].asString();
+		if(!hTTPListenerConfigNode["HealthyThreshold"].isNull())
+			listenersObject.hTTPListenerConfig.healthyThreshold = std::stoi(hTTPListenerConfigNode["HealthyThreshold"].asString());
+		if(!hTTPListenerConfigNode["XForwardedFor_proto"].isNull())
+			listenersObject.hTTPListenerConfig.xForwardedFor_proto = hTTPListenerConfigNode["XForwardedFor_proto"].asString();
+		if(!hTTPListenerConfigNode["XForwardedFor_SLBIP"].isNull())
+			listenersObject.hTTPListenerConfig.xForwardedFor_SLBIP = hTTPListenerConfigNode["XForwardedFor_SLBIP"].asString();
+		if(!hTTPListenerConfigNode["StickySession"].isNull())
+			listenersObject.hTTPListenerConfig.stickySession = hTTPListenerConfigNode["StickySession"].asString();
+		if(!hTTPListenerConfigNode["HealthCheckMethod"].isNull())
+			listenersObject.hTTPListenerConfig.healthCheckMethod = hTTPListenerConfigNode["HealthCheckMethod"].asString();
+		if(!hTTPListenerConfigNode["HealthCheck"].isNull())
+			listenersObject.hTTPListenerConfig.healthCheck = hTTPListenerConfigNode["HealthCheck"].asString();
+		if(!hTTPListenerConfigNode["MaxConnection"].isNull())
+			listenersObject.hTTPListenerConfig.maxConnection = std::stoi(hTTPListenerConfigNode["MaxConnection"].asString());
+		auto hTTPSListenerConfigNode = value["HTTPSListenerConfig"];
+		if(!hTTPSListenerConfigNode["XForwardedFor_ClientCertClientVerify"].isNull())
+			listenersObject.hTTPSListenerConfig.xForwardedFor_ClientCertClientVerify = hTTPSListenerConfigNode["XForwardedFor_ClientCertClientVerify"].asString();
+		if(!hTTPSListenerConfigNode["HealthCheckHttpVersion"].isNull())
+			listenersObject.hTTPSListenerConfig.healthCheckHttpVersion = hTTPSListenerConfigNode["HealthCheckHttpVersion"].asString();
+		if(!hTTPSListenerConfigNode["XForwardedFor_ClientSrcPort"].isNull())
+			listenersObject.hTTPSListenerConfig.xForwardedFor_ClientSrcPort = hTTPSListenerConfigNode["XForwardedFor_ClientSrcPort"].asString();
+		if(!hTTPSListenerConfigNode["Cookie"].isNull())
+			listenersObject.hTTPSListenerConfig.cookie = hTTPSListenerConfigNode["Cookie"].asString();
+		if(!hTTPSListenerConfigNode["Gzip"].isNull())
+			listenersObject.hTTPSListenerConfig.gzip = hTTPSListenerConfigNode["Gzip"].asString();
+		if(!hTTPSListenerConfigNode["EnableHttp2"].isNull())
+			listenersObject.hTTPSListenerConfig.enableHttp2 = hTTPSListenerConfigNode["EnableHttp2"].asString();
+		if(!hTTPSListenerConfigNode["CACertificateId"].isNull())
+			listenersObject.hTTPSListenerConfig.cACertificateId = hTTPSListenerConfigNode["CACertificateId"].asString();
+		if(!hTTPSListenerConfigNode["XForwardedFor_ClientCertClientVerifyAlias"].isNull())
+			listenersObject.hTTPSListenerConfig.xForwardedFor_ClientCertClientVerifyAlias = hTTPSListenerConfigNode["XForwardedFor_ClientCertClientVerifyAlias"].asString();
+		if(!hTTPSListenerConfigNode["HealthCheckConnectPort"].isNull())
+			listenersObject.hTTPSListenerConfig.healthCheckConnectPort = std::stoi(hTTPSListenerConfigNode["HealthCheckConnectPort"].asString());
+		if(!hTTPSListenerConfigNode["HealthCheckTimeout"].isNull())
+			listenersObject.hTTPSListenerConfig.healthCheckTimeout = std::stoi(hTTPSListenerConfigNode["HealthCheckTimeout"].asString());
+		if(!hTTPSListenerConfigNode["HealthCheckType"].isNull())
+			listenersObject.hTTPSListenerConfig.healthCheckType = hTTPSListenerConfigNode["HealthCheckType"].asString();
+		if(!hTTPSListenerConfigNode["CookieTimeout"].isNull())
+			listenersObject.hTTPSListenerConfig.cookieTimeout = std::stoi(hTTPSListenerConfigNode["CookieTimeout"].asString());
+		if(!hTTPSListenerConfigNode["HealthCheckDomain"].isNull())
+			listenersObject.hTTPSListenerConfig.healthCheckDomain = hTTPSListenerConfigNode["HealthCheckDomain"].asString();
+		if(!hTTPSListenerConfigNode["UnhealthyThreshold"].isNull())
+			listenersObject.hTTPSListenerConfig.unhealthyThreshold = std::stoi(hTTPSListenerConfigNode["UnhealthyThreshold"].asString());
+		if(!hTTPSListenerConfigNode["XForwardedFor_SLBID"].isNull())
+			listenersObject.hTTPSListenerConfig.xForwardedFor_SLBID = hTTPSListenerConfigNode["XForwardedFor_SLBID"].asString();
+		if(!hTTPSListenerConfigNode["XForwardedFor_ClientCertSubjectDN"].isNull())
+			listenersObject.hTTPSListenerConfig.xForwardedFor_ClientCertSubjectDN = hTTPSListenerConfigNode["XForwardedFor_ClientCertSubjectDN"].asString();
+		if(!hTTPSListenerConfigNode["HealthCheckHttpCode"].isNull())
+			listenersObject.hTTPSListenerConfig.healthCheckHttpCode = hTTPSListenerConfigNode["HealthCheckHttpCode"].asString();
+		if(!hTTPSListenerConfigNode["XForwardedFor_ClientCertFingerprintAlias"].isNull())
+			listenersObject.hTTPSListenerConfig.xForwardedFor_ClientCertFingerprintAlias = hTTPSListenerConfigNode["XForwardedFor_ClientCertFingerprintAlias"].asString();
+		if(!hTTPSListenerConfigNode["XForwardedFor_ClientCertSubjectDNAlias"].isNull())
+			listenersObject.hTTPSListenerConfig.xForwardedFor_ClientCertSubjectDNAlias = hTTPSListenerConfigNode["XForwardedFor_ClientCertSubjectDNAlias"].asString();
+		if(!hTTPSListenerConfigNode["XForwardedFor_ClientCertIssuerDNAlias"].isNull())
+			listenersObject.hTTPSListenerConfig.xForwardedFor_ClientCertIssuerDNAlias = hTTPSListenerConfigNode["XForwardedFor_ClientCertIssuerDNAlias"].asString();
+		if(!hTTPSListenerConfigNode["XForwardedFor_ClientCertFingerprint"].isNull())
+			listenersObject.hTTPSListenerConfig.xForwardedFor_ClientCertFingerprint = hTTPSListenerConfigNode["XForwardedFor_ClientCertFingerprint"].asString();
+		if(!hTTPSListenerConfigNode["XForwardedFor"].isNull())
+			listenersObject.hTTPSListenerConfig.xForwardedFor = hTTPSListenerConfigNode["XForwardedFor"].asString();
+		if(!hTTPSListenerConfigNode["RequestTimeout"].isNull())
+			listenersObject.hTTPSListenerConfig.requestTimeout = std::stoi(hTTPSListenerConfigNode["RequestTimeout"].asString());
+		if(!hTTPSListenerConfigNode["IdleTimeout"].isNull())
+			listenersObject.hTTPSListenerConfig.idleTimeout = std::stoi(hTTPSListenerConfigNode["IdleTimeout"].asString());
+		if(!hTTPSListenerConfigNode["ServerCertificateId"].isNull())
+			listenersObject.hTTPSListenerConfig.serverCertificateId = hTTPSListenerConfigNode["ServerCertificateId"].asString();
+		if(!hTTPSListenerConfigNode["HealthCheckInterval"].isNull())
+			listenersObject.hTTPSListenerConfig.healthCheckInterval = std::stoi(hTTPSListenerConfigNode["HealthCheckInterval"].asString());
+		if(!hTTPSListenerConfigNode["XForwardedFor_SLBPORT"].isNull())
+			listenersObject.hTTPSListenerConfig.xForwardedFor_SLBPORT = hTTPSListenerConfigNode["XForwardedFor_SLBPORT"].asString();
+		if(!hTTPSListenerConfigNode["HealthCheckURI"].isNull())
+			listenersObject.hTTPSListenerConfig.healthCheckURI = hTTPSListenerConfigNode["HealthCheckURI"].asString();
+		if(!hTTPSListenerConfigNode["StickySessionType"].isNull())
+			listenersObject.hTTPSListenerConfig.stickySessionType = hTTPSListenerConfigNode["StickySessionType"].asString();
+		if(!hTTPSListenerConfigNode["XForwardedFor_ClientCertIssuerDN"].isNull())
+			listenersObject.hTTPSListenerConfig.xForwardedFor_ClientCertIssuerDN = hTTPSListenerConfigNode["XForwardedFor_ClientCertIssuerDN"].asString();
+		if(!hTTPSListenerConfigNode["HealthyThreshold"].isNull())
+			listenersObject.hTTPSListenerConfig.healthyThreshold = std::stoi(hTTPSListenerConfigNode["HealthyThreshold"].asString());
+		if(!hTTPSListenerConfigNode["XForwardedFor_proto"].isNull())
+			listenersObject.hTTPSListenerConfig.xForwardedFor_proto = hTTPSListenerConfigNode["XForwardedFor_proto"].asString();
+		if(!hTTPSListenerConfigNode["XForwardedFor_SLBIP"].isNull())
+			listenersObject.hTTPSListenerConfig.xForwardedFor_SLBIP = hTTPSListenerConfigNode["XForwardedFor_SLBIP"].asString();
+		if(!hTTPSListenerConfigNode["StickySession"].isNull())
+			listenersObject.hTTPSListenerConfig.stickySession = hTTPSListenerConfigNode["StickySession"].asString();
+		if(!hTTPSListenerConfigNode["HealthCheckMethod"].isNull())
+			listenersObject.hTTPSListenerConfig.healthCheckMethod = hTTPSListenerConfigNode["HealthCheckMethod"].asString();
+		if(!hTTPSListenerConfigNode["TLSCipherPolicy"].isNull())
+			listenersObject.hTTPSListenerConfig.tLSCipherPolicy = hTTPSListenerConfigNode["TLSCipherPolicy"].asString();
+		if(!hTTPSListenerConfigNode["HealthCheck"].isNull())
+			listenersObject.hTTPSListenerConfig.healthCheck = hTTPSListenerConfigNode["HealthCheck"].asString();
+		if(!hTTPSListenerConfigNode["MaxConnection"].isNull())
+			listenersObject.hTTPSListenerConfig.maxConnection = std::stoi(hTTPSListenerConfigNode["MaxConnection"].asString());
+		auto allServerCertificatesNode = hTTPSListenerConfigNode["ServerCertificates"]["ServerCertificate"];
+		for (auto hTTPSListenerConfigNodeServerCertificatesServerCertificate : allServerCertificatesNode)
+		{
+			Listener::HTTPSListenerConfig::ServerCertificate serverCertificateObject;
+			if(!hTTPSListenerConfigNodeServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
+				serverCertificateObject.encryptionAlgorithm = hTTPSListenerConfigNodeServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
+			if(!hTTPSListenerConfigNodeServerCertificatesServerCertificate["StandardType"].isNull())
+				serverCertificateObject.standardType = hTTPSListenerConfigNodeServerCertificatesServerCertificate["StandardType"].asString();
+			if(!hTTPSListenerConfigNodeServerCertificatesServerCertificate["BindingType"].isNull())
+				serverCertificateObject.bindingType = hTTPSListenerConfigNodeServerCertificatesServerCertificate["BindingType"].asString();
+			if(!hTTPSListenerConfigNodeServerCertificatesServerCertificate["CertificateId"].isNull())
+				serverCertificateObject.certificateId = hTTPSListenerConfigNodeServerCertificatesServerCertificate["CertificateId"].asString();
+			listenersObject.hTTPSListenerConfig.serverCertificates.push_back(serverCertificateObject);
+		}
+		auto tCPListenerConfigNode = value["TCPListenerConfig"];
+		if(!tCPListenerConfigNode["HealthCheckHttpCode"].isNull())
+			listenersObject.tCPListenerConfig.healthCheckHttpCode = tCPListenerConfigNode["HealthCheckHttpCode"].asString();
+		if(!tCPListenerConfigNode["ConnectionDrainTimeout"].isNull())
+			listenersObject.tCPListenerConfig.connectionDrainTimeout = std::stoi(tCPListenerConfigNode["ConnectionDrainTimeout"].asString());
+		if(!tCPListenerConfigNode["PersistenceTimeout"].isNull())
+			listenersObject.tCPListenerConfig.persistenceTimeout = std::stoi(tCPListenerConfigNode["PersistenceTimeout"].asString());
+		if(!tCPListenerConfigNode["HealthCheckInterval"].isNull())
+			listenersObject.tCPListenerConfig.healthCheckInterval = std::stoi(tCPListenerConfigNode["HealthCheckInterval"].asString());
+		if(!tCPListenerConfigNode["HealthCheckURI"].isNull())
+			listenersObject.tCPListenerConfig.healthCheckURI = tCPListenerConfigNode["HealthCheckURI"].asString();
+		if(!tCPListenerConfigNode["HealthCheckSwitch"].isNull())
+			listenersObject.tCPListenerConfig.healthCheckSwitch = tCPListenerConfigNode["HealthCheckSwitch"].asString();
+		if(!tCPListenerConfigNode["FullNatEnabled"].isNull())
+			listenersObject.tCPListenerConfig.fullNatEnabled = tCPListenerConfigNode["FullNatEnabled"].asString();
+		if(!tCPListenerConfigNode["HealthCheckConnectPort"].isNull())
+			listenersObject.tCPListenerConfig.healthCheckConnectPort = std::stoi(tCPListenerConfigNode["HealthCheckConnectPort"].asString());
+		if(!tCPListenerConfigNode["EstablishedTimeout"].isNull())
+			listenersObject.tCPListenerConfig.establishedTimeout = std::stoi(tCPListenerConfigNode["EstablishedTimeout"].asString());
+		if(!tCPListenerConfigNode["HealthCheckType"].isNull())
+			listenersObject.tCPListenerConfig.healthCheckType = tCPListenerConfigNode["HealthCheckType"].asString();
+		if(!tCPListenerConfigNode["HealthCheckConnectTimeout"].isNull())
+			listenersObject.tCPListenerConfig.healthCheckConnectTimeout = std::stoi(tCPListenerConfigNode["HealthCheckConnectTimeout"].asString());
+		if(!tCPListenerConfigNode["MasterSlaveServerGroupId"].isNull())
+			listenersObject.tCPListenerConfig.masterSlaveServerGroupId = tCPListenerConfigNode["MasterSlaveServerGroupId"].asString();
+		if(!tCPListenerConfigNode["HealthyThreshold"].isNull())
+			listenersObject.tCPListenerConfig.healthyThreshold = std::stoi(tCPListenerConfigNode["HealthyThreshold"].asString());
+		if(!tCPListenerConfigNode["HealthCheckDomain"].isNull())
+			listenersObject.tCPListenerConfig.healthCheckDomain = tCPListenerConfigNode["HealthCheckDomain"].asString();
+		if(!tCPListenerConfigNode["UnhealthyThreshold"].isNull())
+			listenersObject.tCPListenerConfig.unhealthyThreshold = std::stoi(tCPListenerConfigNode["UnhealthyThreshold"].asString());
+		if(!tCPListenerConfigNode["ConnectionDrain"].isNull())
+			listenersObject.tCPListenerConfig.connectionDrain = tCPListenerConfigNode["ConnectionDrain"].asString();
+		if(!tCPListenerConfigNode["HealthCheckMethod"].isNull())
+			listenersObject.tCPListenerConfig.healthCheckMethod = tCPListenerConfigNode["HealthCheckMethod"].asString();
+		if(!tCPListenerConfigNode["HealthCheck"].isNull())
+			listenersObject.tCPListenerConfig.healthCheck = tCPListenerConfigNode["HealthCheck"].asString();
+		if(!tCPListenerConfigNode["ProxyProtocolV2Enabled"].isNull())
+			listenersObject.tCPListenerConfig.proxyProtocolV2Enabled = tCPListenerConfigNode["ProxyProtocolV2Enabled"].asString();
+		if(!tCPListenerConfigNode["HealthCheckTcpFastCloseEnabled"].isNull())
+			listenersObject.tCPListenerConfig.healthCheckTcpFastCloseEnabled = tCPListenerConfigNode["HealthCheckTcpFastCloseEnabled"].asString() == "true";
+		if(!tCPListenerConfigNode["MasterSlaveModeEnabled"].isNull())
+			listenersObject.tCPListenerConfig.masterSlaveModeEnabled = tCPListenerConfigNode["MasterSlaveModeEnabled"].asString() == "true";
+		if(!tCPListenerConfigNode["MasterServerGroupId"].isNull())
+			listenersObject.tCPListenerConfig.masterServerGroupId = tCPListenerConfigNode["MasterServerGroupId"].asString();
+		if(!tCPListenerConfigNode["SlaveServerGroupId"].isNull())
+			listenersObject.tCPListenerConfig.slaveServerGroupId = tCPListenerConfigNode["SlaveServerGroupId"].asString();
+		if(!tCPListenerConfigNode["FailoverThreshold"].isNull())
+			listenersObject.tCPListenerConfig.failoverThreshold = std::stoi(tCPListenerConfigNode["FailoverThreshold"].asString());
+		if(!tCPListenerConfigNode["FailoverStrategy"].isNull())
+			listenersObject.tCPListenerConfig.failoverStrategy = tCPListenerConfigNode["FailoverStrategy"].asString();
+		if(!tCPListenerConfigNode["MaxConnection"].isNull())
+			listenersObject.tCPListenerConfig.maxConnection = std::stoi(tCPListenerConfigNode["MaxConnection"].asString());
+		auto allPortRangesNode = tCPListenerConfigNode["PortRanges"]["PortRange"];
+		for (auto tCPListenerConfigNodePortRangesPortRange : allPortRangesNode)
+		{
+			Listener::TCPListenerConfig::PortRange portRangeObject;
+			if(!tCPListenerConfigNodePortRangesPortRange["StartPort"].isNull())
+				portRangeObject.startPort = std::stoi(tCPListenerConfigNodePortRangesPortRange["StartPort"].asString());
+			if(!tCPListenerConfigNodePortRangesPortRange["EndPort"].isNull())
+				portRangeObject.endPort = std::stoi(tCPListenerConfigNodePortRangesPortRange["EndPort"].asString());
+			listenersObject.tCPListenerConfig.portRanges.push_back(portRangeObject);
+		}
+		auto tCPSListenerConfigNode = value["TCPSListenerConfig"];
+		if(!tCPSListenerConfigNode["HealthCheckHttpCode"].isNull())
+			listenersObject.tCPSListenerConfig.healthCheckHttpCode = tCPSListenerConfigNode["HealthCheckHttpCode"].asString();
+		if(!tCPSListenerConfigNode["Cookie"].isNull())
+			listenersObject.tCPSListenerConfig.cookie = tCPSListenerConfigNode["Cookie"].asString();
+		if(!tCPSListenerConfigNode["IdleTimeout"].isNull())
+			listenersObject.tCPSListenerConfig.idleTimeout = std::stoi(tCPSListenerConfigNode["IdleTimeout"].asString());
+		if(!tCPSListenerConfigNode["ServerCertificateId"].isNull())
+			listenersObject.tCPSListenerConfig.serverCertificateId = tCPSListenerConfigNode["ServerCertificateId"].asString();
+		if(!tCPSListenerConfigNode["HealthCheckInterval"].isNull())
+			listenersObject.tCPSListenerConfig.healthCheckInterval = std::stoi(tCPSListenerConfigNode["HealthCheckInterval"].asString());
+		if(!tCPSListenerConfigNode["HealthCheckURI"].isNull())
+			listenersObject.tCPSListenerConfig.healthCheckURI = tCPSListenerConfigNode["HealthCheckURI"].asString();
+		if(!tCPSListenerConfigNode["CACertificateId"].isNull())
+			listenersObject.tCPSListenerConfig.cACertificateId = tCPSListenerConfigNode["CACertificateId"].asString();
+		if(!tCPSListenerConfigNode["StickySessionType"].isNull())
+			listenersObject.tCPSListenerConfig.stickySessionType = tCPSListenerConfigNode["StickySessionType"].asString();
+		if(!tCPSListenerConfigNode["HealthCheckConnectPort"].isNull())
+			listenersObject.tCPSListenerConfig.healthCheckConnectPort = std::stoi(tCPSListenerConfigNode["HealthCheckConnectPort"].asString());
+		if(!tCPSListenerConfigNode["HealthCheckTimeout"].isNull())
+			listenersObject.tCPSListenerConfig.healthCheckTimeout = std::stoi(tCPSListenerConfigNode["HealthCheckTimeout"].asString());
+		if(!tCPSListenerConfigNode["HealthCheckType"].isNull())
+			listenersObject.tCPSListenerConfig.healthCheckType = tCPSListenerConfigNode["HealthCheckType"].asString();
+		if(!tCPSListenerConfigNode["HealthyThreshold"].isNull())
+			listenersObject.tCPSListenerConfig.healthyThreshold = std::stoi(tCPSListenerConfigNode["HealthyThreshold"].asString());
+		if(!tCPSListenerConfigNode["CookieTimeout"].isNull())
+			listenersObject.tCPSListenerConfig.cookieTimeout = std::stoi(tCPSListenerConfigNode["CookieTimeout"].asString());
+		if(!tCPSListenerConfigNode["HealthCheckDomain"].isNull())
+			listenersObject.tCPSListenerConfig.healthCheckDomain = tCPSListenerConfigNode["HealthCheckDomain"].asString();
+		if(!tCPSListenerConfigNode["UnhealthyThreshold"].isNull())
+			listenersObject.tCPSListenerConfig.unhealthyThreshold = std::stoi(tCPSListenerConfigNode["UnhealthyThreshold"].asString());
+		if(!tCPSListenerConfigNode["StickySession"].isNull())
+			listenersObject.tCPSListenerConfig.stickySession = tCPSListenerConfigNode["StickySession"].asString();
+		if(!tCPSListenerConfigNode["HealthCheckMethod"].isNull())
+			listenersObject.tCPSListenerConfig.healthCheckMethod = tCPSListenerConfigNode["HealthCheckMethod"].asString();
+		if(!tCPSListenerConfigNode["TLSCipherPolicy"].isNull())
+			listenersObject.tCPSListenerConfig.tLSCipherPolicy = tCPSListenerConfigNode["TLSCipherPolicy"].asString();
+		if(!tCPSListenerConfigNode["HealthCheck"].isNull())
+			listenersObject.tCPSListenerConfig.healthCheck = tCPSListenerConfigNode["HealthCheck"].asString();
+		auto uDPListenerConfigNode = value["UDPListenerConfig"];
+		if(!uDPListenerConfigNode["HealthCheckHttpCode"].isNull())
+			listenersObject.uDPListenerConfig.healthCheckHttpCode = uDPListenerConfigNode["HealthCheckHttpCode"].asString();
+		if(!uDPListenerConfigNode["ConnectionDrainTimeout"].isNull())
+			listenersObject.uDPListenerConfig.connectionDrainTimeout = std::stoi(uDPListenerConfigNode["ConnectionDrainTimeout"].asString());
+		if(!uDPListenerConfigNode["HealthCheckInterval"].isNull())
+			listenersObject.uDPListenerConfig.healthCheckInterval = std::stoi(uDPListenerConfigNode["HealthCheckInterval"].asString());
+		if(!uDPListenerConfigNode["HealthCheckExp"].isNull())
+			listenersObject.uDPListenerConfig.healthCheckExp = uDPListenerConfigNode["HealthCheckExp"].asString();
+		if(!uDPListenerConfigNode["HealthCheckURI"].isNull())
+			listenersObject.uDPListenerConfig.healthCheckURI = uDPListenerConfigNode["HealthCheckURI"].asString();
+		if(!uDPListenerConfigNode["HealthCheckSwitch"].isNull())
+			listenersObject.uDPListenerConfig.healthCheckSwitch = uDPListenerConfigNode["HealthCheckSwitch"].asString();
+		if(!uDPListenerConfigNode["FullNatEnabled"].isNull())
+			listenersObject.uDPListenerConfig.fullNatEnabled = uDPListenerConfigNode["FullNatEnabled"].asString();
+		if(!uDPListenerConfigNode["HealthCheckConnectPort"].isNull())
+			listenersObject.uDPListenerConfig.healthCheckConnectPort = std::stoi(uDPListenerConfigNode["HealthCheckConnectPort"].asString());
+		if(!uDPListenerConfigNode["HealthCheckType"].isNull())
+			listenersObject.uDPListenerConfig.healthCheckType = uDPListenerConfigNode["HealthCheckType"].asString();
+		if(!uDPListenerConfigNode["HealthCheckConnectTimeout"].isNull())
+			listenersObject.uDPListenerConfig.healthCheckConnectTimeout = std::stoi(uDPListenerConfigNode["HealthCheckConnectTimeout"].asString());
+		if(!uDPListenerConfigNode["MasterSlaveServerGroupId"].isNull())
+			listenersObject.uDPListenerConfig.masterSlaveServerGroupId = uDPListenerConfigNode["MasterSlaveServerGroupId"].asString();
+		if(!uDPListenerConfigNode["HealthyThreshold"].isNull())
+			listenersObject.uDPListenerConfig.healthyThreshold = std::stoi(uDPListenerConfigNode["HealthyThreshold"].asString());
+		if(!uDPListenerConfigNode["HealthCheckDomain"].isNull())
+			listenersObject.uDPListenerConfig.healthCheckDomain = uDPListenerConfigNode["HealthCheckDomain"].asString();
+		if(!uDPListenerConfigNode["UnhealthyThreshold"].isNull())
+			listenersObject.uDPListenerConfig.unhealthyThreshold = std::stoi(uDPListenerConfigNode["UnhealthyThreshold"].asString());
+		if(!uDPListenerConfigNode["ConnectionDrain"].isNull())
+			listenersObject.uDPListenerConfig.connectionDrain = uDPListenerConfigNode["ConnectionDrain"].asString();
+		if(!uDPListenerConfigNode["HealthCheckReq"].isNull())
+			listenersObject.uDPListenerConfig.healthCheckReq = uDPListenerConfigNode["HealthCheckReq"].asString();
+		if(!uDPListenerConfigNode["HealthCheckMethod"].isNull())
+			listenersObject.uDPListenerConfig.healthCheckMethod = uDPListenerConfigNode["HealthCheckMethod"].asString();
+		if(!uDPListenerConfigNode["HealthCheck"].isNull())
+			listenersObject.uDPListenerConfig.healthCheck = uDPListenerConfigNode["HealthCheck"].asString();
+		if(!uDPListenerConfigNode["ProxyProtocolV2Enabled"].isNull())
+			listenersObject.uDPListenerConfig.proxyProtocolV2Enabled = uDPListenerConfigNode["ProxyProtocolV2Enabled"].asString();
+		if(!uDPListenerConfigNode["QuicVersion"].isNull())
+			listenersObject.uDPListenerConfig.quicVersion = uDPListenerConfigNode["QuicVersion"].asString();
+		if(!uDPListenerConfigNode["PersistenceTimeout"].isNull())
+			listenersObject.uDPListenerConfig.persistenceTimeout = std::stoi(uDPListenerConfigNode["PersistenceTimeout"].asString());
+		if(!uDPListenerConfigNode["MasterSlaveModeEnabled"].isNull())
+			listenersObject.uDPListenerConfig.masterSlaveModeEnabled = uDPListenerConfigNode["MasterSlaveModeEnabled"].asString() == "true";
+		if(!uDPListenerConfigNode["MasterServerGroupId"].isNull())
+			listenersObject.uDPListenerConfig.masterServerGroupId = uDPListenerConfigNode["MasterServerGroupId"].asString();
+		if(!uDPListenerConfigNode["SlaveServerGroupId"].isNull())
+			listenersObject.uDPListenerConfig.slaveServerGroupId = uDPListenerConfigNode["SlaveServerGroupId"].asString();
+		if(!uDPListenerConfigNode["FailoverThreshold"].isNull())
+			listenersObject.uDPListenerConfig.failoverThreshold = std::stoi(uDPListenerConfigNode["FailoverThreshold"].asString());
+		if(!uDPListenerConfigNode["FailoverStrategy"].isNull())
+			listenersObject.uDPListenerConfig.failoverStrategy = uDPListenerConfigNode["FailoverStrategy"].asString();
+		if(!uDPListenerConfigNode["MaxConnection"].isNull())
+			listenersObject.uDPListenerConfig.maxConnection = std::stoi(uDPListenerConfigNode["MaxConnection"].asString());
+		auto allPortRanges1Node = uDPListenerConfigNode["PortRanges"]["PortRange"];
+		for (auto uDPListenerConfigNodePortRangesPortRange : allPortRanges1Node)
+		{
+			Listener::UDPListenerConfig::PortRange2 portRange2Object;
+			if(!uDPListenerConfigNodePortRangesPortRange["StartPort"].isNull())
+				portRange2Object.startPort = std::stoi(uDPListenerConfigNodePortRangesPortRange["StartPort"].asString());
+			if(!uDPListenerConfigNodePortRangesPortRange["EndPort"].isNull())
+				portRange2Object.endPort = std::stoi(uDPListenerConfigNodePortRangesPortRange["EndPort"].asString());
+			listenersObject.uDPListenerConfig.portRanges1.push_back(portRange2Object);
+		}
+		auto allAclIds = value["AclIds"]["AclId"];
+		for (auto value : allAclIds)
+			listenersObject.aclIds.push_back(value.asString());
+		listeners_.push_back(listenersObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+	if(!value["MaxResults"].isNull())
+		maxResults_ = std::stoi(value["MaxResults"].asString());
+
+}
+
+std::vector<DescribeLoadBalancerListenersResult::Listener> DescribeLoadBalancerListenersResult::getListeners()const
+{
+	return listeners_;
+}
+
+int DescribeLoadBalancerListenersResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::string DescribeLoadBalancerListenersResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+int DescribeLoadBalancerListenersResult::getMaxResults()const
+{
+	return maxResults_;
+}
+

slb/src/model/DescribeLoadBalancerTCPListenerAttributeRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::Slb::Model::DescribeLoadBalancerTCPListenerAttributeRequest;
 
 DescribeLoadBalancerTCPListenerAttributeRequest::DescribeLoadBalancerTCPListenerAttributeRequest()
-    : RpcServiceRequest("slb", "2013-02-21", "DescribeLoadBalancerTCPListenerAttribute") {
+    : RpcServiceRequest("slb", "2014-05-15", "DescribeLoadBalancerTCPListenerAttribute") {
   setMethod(HttpRequest::Method::Post);
 }
 
@@ -43,13 +43,13 @@ void DescribeLoadBalancerTCPListenerAttributeRequest::setResourceOwnerId(long re
   setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-std::string DescribeLoadBalancerTCPListenerAttributeRequest::getAccessKeyId() const {
-  return accessKeyId_;
+std::string DescribeLoadBalancerTCPListenerAttributeRequest::getRegionId() const {
+  return regionId_;
 }
 
-void DescribeLoadBalancerTCPListenerAttributeRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
+void DescribeLoadBalancerTCPListenerAttributeRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
 int DescribeLoadBalancerTCPListenerAttributeRequest::getListenerPort() const {

slb/src/model/DescribeLoadBalancerTCPListenerAttributeResult.cc

@@ -39,56 +39,112 @@ void DescribeLoadBalancerTCPListenerAttributeResult::parse(const std::string &pa
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	auto allPortRangesNode = value["PortRanges"]["PortRange"];
+	for (auto valuePortRangesPortRange : allPortRangesNode)
+	{
+		PortRange portRangesObject;
+		if(!valuePortRangesPortRange["StartPort"].isNull())
+			portRangesObject.startPort = std::stoi(valuePortRangesPortRange["StartPort"].asString());
+		if(!valuePortRangesPortRange["EndPort"].isNull())
+			portRangesObject.endPort = std::stoi(valuePortRangesPortRange["EndPort"].asString());
+		portRanges_.push_back(portRangesObject);
+	}
+	auto allTagsNode = value["Tags"]["Tag"];
+	for (auto valueTagsTag : allTagsNode)
+	{
+		Tag tagsObject;
+		if(!valueTagsTag["TagKey"].isNull())
+			tagsObject.tagKey = valueTagsTag["TagKey"].asString();
+		if(!valueTagsTag["TagValue"].isNull())
+			tagsObject.tagValue = valueTagsTag["TagValue"].asString();
+		tags_.push_back(tagsObject);
+	}
+	auto allAclIds = value["AclIds"]["AclId"];
+	for (const auto &item : allAclIds)
+		aclIds_.push_back(item.asString());
 	if(!value["VServerGroupId"].isNull())
 		vServerGroupId_ = value["VServerGroupId"].asString();
-	if(!value["HealthCheckHttpCode"].isNull())
-		healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
-	if(!value["ConnectPort"].isNull())
-		connectPort_ = std::stoi(value["ConnectPort"].asString());
 	if(!value["Status"].isNull())
 		status_ = value["Status"].asString();
-	if(!value["MaxConnection"].isNull())
-		maxConnection_ = std::stoi(value["MaxConnection"].asString());
-	if(!value["PersistenceTimeout"].isNull())
-		persistenceTimeout_ = std::stoi(value["PersistenceTimeout"].asString());
-	if(!value["ListenerPort"].isNull())
-		listenerPort_ = std::stoi(value["ListenerPort"].asString());
-	if(!value["HealthCheckURI"].isNull())
-		healthCheckURI_ = value["HealthCheckURI"].asString();
-	if(!value["SynProxy"].isNull())
-		synProxy_ = value["SynProxy"].asString();
-	if(!value["Scheduler"].isNull())
-		scheduler_ = value["Scheduler"].asString();
-	if(!value["Interval"].isNull())
-		interval_ = std::stoi(value["Interval"].asString());
+	if(!value["AclType"].isNull())
+		aclType_ = value["AclType"].asString();
+	if(!value["ConnectionDrainTimeout"].isNull())
+		connectionDrainTimeout_ = std::stoi(value["ConnectionDrainTimeout"].asString());
+	if(!value["FailoverStrategy"].isNull())
+		failoverStrategy_ = value["FailoverStrategy"].asString();
+	if(!value["WorkingServerGroupId"].isNull())
+		workingServerGroupId_ = value["WorkingServerGroupId"].asString();
+	if(!value["HealthCheckTcpFastCloseEnabled"].isNull())
+		healthCheckTcpFastCloseEnabled_ = value["HealthCheckTcpFastCloseEnabled"].asString() == "true";
+	if(!value["FullNatEnabled"].isNull())
+		fullNatEnabled_ = value["FullNatEnabled"].asString() == "true";
+	if(!value["ServiceManagedMode"].isNull())
+		serviceManagedMode_ = value["ServiceManagedMode"].asString();
+	if(!value["HealthCheckConnectPort"].isNull())
+		healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
 	if(!value["Bandwidth"].isNull())
 		bandwidth_ = std::stoi(value["Bandwidth"].asString());
-	if(!value["EstablishedTimeout"].isNull())
-		establishedTimeout_ = std::stoi(value["EstablishedTimeout"].asString());
 	if(!value["HealthCheckType"].isNull())
 		healthCheckType_ = value["HealthCheckType"].asString();
 	if(!value["MasterSlaveServerGroupId"].isNull())
 		masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
 	if(!value["BackendServerPort"].isNull())
 		backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
-	if(!value["HealthyThreshold"].isNull())
-		healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
+	if(!value["AclStatus"].isNull())
+		aclStatus_ = value["AclStatus"].asString();
 	if(!value["HealthCheckDomain"].isNull())
 		healthCheckDomain_ = value["HealthCheckDomain"].asString();
 	if(!value["UnhealthyThreshold"].isNull())
 		unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
-	if(!value["ConnectTimeout"].isNull())
-		connectTimeout_ = std::stoi(value["ConnectTimeout"].asString());
+	if(!value["MasterServerGroupId"].isNull())
+		masterServerGroupId_ = value["MasterServerGroupId"].asString();
+	if(!value["HealthCheckHttpCode"].isNull())
+		healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
+	if(!value["MaxConnection"].isNull())
+		maxConnection_ = std::stoi(value["MaxConnection"].asString());
+	if(!value["ProxyProtocolV2Enabled"].isNull())
+		proxyProtocolV2Enabled_ = value["ProxyProtocolV2Enabled"].asString() == "true";
+	if(!value["SlaveServerGroupId"].isNull())
+		slaveServerGroupId_ = value["SlaveServerGroupId"].asString();
+	if(!value["PersistenceTimeout"].isNull())
+		persistenceTimeout_ = std::stoi(value["PersistenceTimeout"].asString());
+	if(!value["ListenerPort"].isNull())
+		listenerPort_ = std::stoi(value["ListenerPort"].asString());
+	if(!value["HealthCheckInterval"].isNull())
+		healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
+	if(!value["HealthCheckURI"].isNull())
+		healthCheckURI_ = value["HealthCheckURI"].asString();
+	if(!value["FailoverThreshold"].isNull())
+		failoverThreshold_ = std::stoi(value["FailoverThreshold"].asString());
+	if(!value["AclId"].isNull())
+		aclId_ = value["AclId"].asString();
+	if(!value["SynProxy"].isNull())
+		synProxy_ = value["SynProxy"].asString();
+	if(!value["Scheduler"].isNull())
+		scheduler_ = value["Scheduler"].asString();
+	if(!value["EstablishedTimeout"].isNull())
+		establishedTimeout_ = std::stoi(value["EstablishedTimeout"].asString());
+	if(!value["VpcIds"].isNull())
+		vpcIds_ = value["VpcIds"].asString();
+	if(!value["HealthCheckConnectTimeout"].isNull())
+		healthCheckConnectTimeout_ = std::stoi(value["HealthCheckConnectTimeout"].asString());
+	if(!value["MasterSlaveModeEnabled"].isNull())
+		masterSlaveModeEnabled_ = value["MasterSlaveModeEnabled"].asString() == "true";
+	if(!value["HealthyThreshold"].isNull())
+		healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
+	if(!value["ConnectionDrain"].isNull())
+		connectionDrain_ = value["ConnectionDrain"].asString();
+	if(!value["HealthCheckMethod"].isNull())
+		healthCheckMethod_ = value["HealthCheckMethod"].asString();
 	if(!value["HealthCheck"].isNull())
 		healthCheck_ = value["HealthCheck"].asString();
+	if(!value["LoadBalancerId"].isNull())
+		loadBalancerId_ = value["LoadBalancerId"].asString();
 
 }
 
-std::string DescribeLoadBalancerTCPListenerAttributeResult::getStatus()const
-{
-	return status_;
-}
-
 int DescribeLoadBalancerTCPListenerAttributeResult::getMaxConnection()const
 {
 	return maxConnection_;
@@ -99,19 +155,9 @@ std::string DescribeLoadBalancerTCPListenerAttributeResult::getVServerGroupId()c
 	return vServerGroupId_;
 }
 
-int DescribeLoadBalancerTCPListenerAttributeResult::getListenerPort()const
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getDescription()const
 {
-	return listenerPort_;
-}
-
-int DescribeLoadBalancerTCPListenerAttributeResult::getConnectTimeout()const
-{
-	return connectTimeout_;
-}
-
-int DescribeLoadBalancerTCPListenerAttributeResult::getConnectPort()const
-{
-	return connectPort_;
+	return description_;
 }
 
 std::string DescribeLoadBalancerTCPListenerAttributeResult::getSynProxy()const
@@ -124,6 +170,16 @@ int DescribeLoadBalancerTCPListenerAttributeResult::getUnhealthyThreshold()const
 	return unhealthyThreshold_;
 }
 
+bool DescribeLoadBalancerTCPListenerAttributeResult::getProxyProtocolV2Enabled()const
+{
+	return proxyProtocolV2Enabled_;
+}
+
+int DescribeLoadBalancerTCPListenerAttributeResult::getFailoverThreshold()const
+{
+	return failoverThreshold_;
+}
+
 std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckURI()const
 {
 	return healthCheckURI_;
@@ -139,21 +195,136 @@ std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheck()cons
 	return healthCheck_;
 }
 
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getLoadBalancerId()const
+{
+	return loadBalancerId_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getWorkingServerGroupId()const
+{
+	return workingServerGroupId_;
+}
+
 int DescribeLoadBalancerTCPListenerAttributeResult::getBackendServerPort()const
 {
 	return backendServerPort_;
 }
 
+bool DescribeLoadBalancerTCPListenerAttributeResult::getMasterSlaveModeEnabled()const
+{
+	return masterSlaveModeEnabled_;
+}
+
+bool DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckTcpFastCloseEnabled()const
+{
+	return healthCheckTcpFastCloseEnabled_;
+}
+
+int DescribeLoadBalancerTCPListenerAttributeResult::getConnectionDrainTimeout()const
+{
+	return connectionDrainTimeout_;
+}
+
 int DescribeLoadBalancerTCPListenerAttributeResult::getPersistenceTimeout()const
 {
 	return persistenceTimeout_;
 }
 
+int DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckConnectPort()const
+{
+	return healthCheckConnectPort_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getMasterServerGroupId()const
+{
+	return masterServerGroupId_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckMethod()const
+{
+	return healthCheckMethod_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getServiceManagedMode()const
+{
+	return serviceManagedMode_;
+}
+
 int DescribeLoadBalancerTCPListenerAttributeResult::getBandwidth()const
 {
 	return bandwidth_;
 }
 
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckHttpCode()const
+{
+	return healthCheckHttpCode_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getSlaveServerGroupId()const
+{
+	return slaveServerGroupId_;
+}
+
+std::vector<DescribeLoadBalancerTCPListenerAttributeResult::Tag> DescribeLoadBalancerTCPListenerAttributeResult::getTags()const
+{
+	return tags_;
+}
+
+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::vector<DescribeLoadBalancerTCPListenerAttributeResult::PortRange> DescribeLoadBalancerTCPListenerAttributeResult::getPortRanges()const
+{
+	return portRanges_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getAclId()const
+{
+	return aclId_;
+}
+
+int DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckConnectTimeout()const
+{
+	return healthCheckConnectTimeout_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getConnectionDrain()const
+{
+	return connectionDrain_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getAclStatus()const
+{
+	return aclStatus_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getVpcIds()const
+{
+	return vpcIds_;
+}
+
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getFailoverStrategy()const
+{
+	return failoverStrategy_;
+}
+
 int DescribeLoadBalancerTCPListenerAttributeResult::getHealthyThreshold()const
 {
 	return healthyThreshold_;
@@ -169,9 +340,19 @@ std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckDomain
 	return healthCheckDomain_;
 }
 
-std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckHttpCode()const
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getAclType()const
 {
-	return healthCheckHttpCode_;
+	return aclType_;
+}
+
+bool DescribeLoadBalancerTCPListenerAttributeResult::getFullNatEnabled()const
+{
+	return fullNatEnabled_;
+}
+
+std::vector<std::string> DescribeLoadBalancerTCPListenerAttributeResult::getAclIds()const
+{
+	return aclIds_;
 }
 
 std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckType()const
@@ -179,13 +360,3 @@ std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckType()
 	return healthCheckType_;
 }
 
-int DescribeLoadBalancerTCPListenerAttributeResult::getInterval()const
-{
-	return interval_;
-}
-
-int DescribeLoadBalancerTCPListenerAttributeResult::getEstablishedTimeout()const
-{
-	return establishedTimeout_;
-}
-

slb/src/model/DescribeLoadBalancerUDPListenerAttributeRequest.cc

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

slb/src/model/DescribeLoadBalancerUDPListenerAttributeResult.cc

@@ -0,0 +1,369 @@
+/*
+ * 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/DescribeLoadBalancerUDPListenerAttributeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DescribeLoadBalancerUDPListenerAttributeResult::DescribeLoadBalancerUDPListenerAttributeResult() :
+	ServiceResult()
+{}
+
+DescribeLoadBalancerUDPListenerAttributeResult::DescribeLoadBalancerUDPListenerAttributeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLoadBalancerUDPListenerAttributeResult::~DescribeLoadBalancerUDPListenerAttributeResult()
+{}
+
+void DescribeLoadBalancerUDPListenerAttributeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allPortRangesNode = value["PortRanges"]["PortRange"];
+	for (auto valuePortRangesPortRange : allPortRangesNode)
+	{
+		PortRange portRangesObject;
+		if(!valuePortRangesPortRange["StartPort"].isNull())
+			portRangesObject.startPort = std::stoi(valuePortRangesPortRange["StartPort"].asString());
+		if(!valuePortRangesPortRange["EndPort"].isNull())
+			portRangesObject.endPort = std::stoi(valuePortRangesPortRange["EndPort"].asString());
+		portRanges_.push_back(portRangesObject);
+	}
+	auto allTagsNode = value["Tags"]["Tag"];
+	for (auto valueTagsTag : allTagsNode)
+	{
+		Tag tagsObject;
+		if(!valueTagsTag["TagKey"].isNull())
+			tagsObject.tagKey = valueTagsTag["TagKey"].asString();
+		if(!valueTagsTag["TagValue"].isNull())
+			tagsObject.tagValue = valueTagsTag["TagValue"].asString();
+		tags_.push_back(tagsObject);
+	}
+	auto allAclIds = value["AclIds"]["AclId"];
+	for (const auto &item : allAclIds)
+		aclIds_.push_back(item.asString());
+	if(!value["VServerGroupId"].isNull())
+		vServerGroupId_ = value["VServerGroupId"].asString();
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["AclType"].isNull())
+		aclType_ = value["AclType"].asString();
+	if(!value["ConnectionDrainTimeout"].isNull())
+		connectionDrainTimeout_ = std::stoi(value["ConnectionDrainTimeout"].asString());
+	if(!value["FailoverStrategy"].isNull())
+		failoverStrategy_ = value["FailoverStrategy"].asString();
+	if(!value["WorkingServerGroupId"].isNull())
+		workingServerGroupId_ = value["WorkingServerGroupId"].asString();
+	if(!value["HealthCheckSwitch"].isNull())
+		healthCheckSwitch_ = value["HealthCheckSwitch"].asString();
+	if(!value["FullNatEnabled"].isNull())
+		fullNatEnabled_ = value["FullNatEnabled"].asString() == "true";
+	if(!value["ServiceManagedMode"].isNull())
+		serviceManagedMode_ = value["ServiceManagedMode"].asString();
+	if(!value["QuicVersion"].isNull())
+		quicVersion_ = value["QuicVersion"].asString();
+	if(!value["HealthCheckConnectPort"].isNull())
+		healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
+	if(!value["Bandwidth"].isNull())
+		bandwidth_ = std::stoi(value["Bandwidth"].asString());
+	if(!value["HealthCheckType"].isNull())
+		healthCheckType_ = value["HealthCheckType"].asString();
+	if(!value["MasterSlaveServerGroupId"].isNull())
+		masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
+	if(!value["BackendServerPort"].isNull())
+		backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
+	if(!value["AclStatus"].isNull())
+		aclStatus_ = value["AclStatus"].asString();
+	if(!value["HealthCheckDomain"].isNull())
+		healthCheckDomain_ = value["HealthCheckDomain"].asString();
+	if(!value["UnhealthyThreshold"].isNull())
+		unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
+	if(!value["MasterServerGroupId"].isNull())
+		masterServerGroupId_ = value["MasterServerGroupId"].asString();
+	if(!value["HealthCheckHttpCode"].isNull())
+		healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
+	if(!value["MaxConnection"].isNull())
+		maxConnection_ = std::stoi(value["MaxConnection"].asString());
+	if(!value["ProxyProtocolV2Enabled"].isNull())
+		proxyProtocolV2Enabled_ = value["ProxyProtocolV2Enabled"].asString() == "true";
+	if(!value["SlaveServerGroupId"].isNull())
+		slaveServerGroupId_ = value["SlaveServerGroupId"].asString();
+	if(!value["PersistenceTimeout"].isNull())
+		persistenceTimeout_ = std::stoi(value["PersistenceTimeout"].asString());
+	if(!value["ListenerPort"].isNull())
+		listenerPort_ = std::stoi(value["ListenerPort"].asString());
+	if(!value["HealthCheckInterval"].isNull())
+		healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
+	if(!value["HealthCheckExp"].isNull())
+		healthCheckExp_ = value["HealthCheckExp"].asString();
+	if(!value["HealthCheckURI"].isNull())
+		healthCheckURI_ = value["HealthCheckURI"].asString();
+	if(!value["FailoverThreshold"].isNull())
+		failoverThreshold_ = std::stoi(value["FailoverThreshold"].asString());
+	if(!value["AclId"].isNull())
+		aclId_ = value["AclId"].asString();
+	if(!value["Scheduler"].isNull())
+		scheduler_ = value["Scheduler"].asString();
+	if(!value["VpcIds"].isNull())
+		vpcIds_ = value["VpcIds"].asString();
+	if(!value["HealthCheckConnectTimeout"].isNull())
+		healthCheckConnectTimeout_ = std::stoi(value["HealthCheckConnectTimeout"].asString());
+	if(!value["MasterSlaveModeEnabled"].isNull())
+		masterSlaveModeEnabled_ = value["MasterSlaveModeEnabled"].asString() == "true";
+	if(!value["HealthyThreshold"].isNull())
+		healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
+	if(!value["ConnectionDrain"].isNull())
+		connectionDrain_ = value["ConnectionDrain"].asString();
+	if(!value["HealthCheckReq"].isNull())
+		healthCheckReq_ = value["HealthCheckReq"].asString();
+	if(!value["HealthCheckMethod"].isNull())
+		healthCheckMethod_ = value["HealthCheckMethod"].asString();
+	if(!value["HealthCheck"].isNull())
+		healthCheck_ = value["HealthCheck"].asString();
+	if(!value["LoadBalancerId"].isNull())
+		loadBalancerId_ = value["LoadBalancerId"].asString();
+
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getMaxConnection()const
+{
+	return maxConnection_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getVServerGroupId()const
+{
+	return vServerGroupId_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getDescription()const
+{
+	return description_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getUnhealthyThreshold()const
+{
+	return unhealthyThreshold_;
+}
+
+bool DescribeLoadBalancerUDPListenerAttributeResult::getProxyProtocolV2Enabled()const
+{
+	return proxyProtocolV2Enabled_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getFailoverThreshold()const
+{
+	return failoverThreshold_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckURI()const
+{
+	return healthCheckURI_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getScheduler()const
+{
+	return scheduler_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheck()const
+{
+	return healthCheck_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getLoadBalancerId()const
+{
+	return loadBalancerId_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getWorkingServerGroupId()const
+{
+	return workingServerGroupId_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getBackendServerPort()const
+{
+	return backendServerPort_;
+}
+
+bool DescribeLoadBalancerUDPListenerAttributeResult::getMasterSlaveModeEnabled()const
+{
+	return masterSlaveModeEnabled_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getConnectionDrainTimeout()const
+{
+	return connectionDrainTimeout_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getPersistenceTimeout()const
+{
+	return persistenceTimeout_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckConnectPort()const
+{
+	return healthCheckConnectPort_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getMasterServerGroupId()const
+{
+	return masterServerGroupId_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckMethod()const
+{
+	return healthCheckMethod_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getServiceManagedMode()const
+{
+	return serviceManagedMode_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getBandwidth()const
+{
+	return bandwidth_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getQuicVersion()const
+{
+	return quicVersion_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckHttpCode()const
+{
+	return healthCheckHttpCode_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getSlaveServerGroupId()const
+{
+	return slaveServerGroupId_;
+}
+
+std::vector<DescribeLoadBalancerUDPListenerAttributeResult::Tag> DescribeLoadBalancerUDPListenerAttributeResult::getTags()const
+{
+	return tags_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getStatus()const
+{
+	return status_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getListenerPort()const
+{
+	return listenerPort_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckInterval()const
+{
+	return healthCheckInterval_;
+}
+
+std::vector<DescribeLoadBalancerUDPListenerAttributeResult::PortRange> DescribeLoadBalancerUDPListenerAttributeResult::getPortRanges()const
+{
+	return portRanges_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getAclId()const
+{
+	return aclId_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckConnectTimeout()const
+{
+	return healthCheckConnectTimeout_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getConnectionDrain()const
+{
+	return connectionDrain_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckSwitch()const
+{
+	return healthCheckSwitch_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getAclStatus()const
+{
+	return aclStatus_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckReq()const
+{
+	return healthCheckReq_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getVpcIds()const
+{
+	return vpcIds_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getFailoverStrategy()const
+{
+	return failoverStrategy_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckExp()const
+{
+	return healthCheckExp_;
+}
+
+int DescribeLoadBalancerUDPListenerAttributeResult::getHealthyThreshold()const
+{
+	return healthyThreshold_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getMasterSlaveServerGroupId()const
+{
+	return masterSlaveServerGroupId_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckDomain()const
+{
+	return healthCheckDomain_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getAclType()const
+{
+	return aclType_;
+}
+
+bool DescribeLoadBalancerUDPListenerAttributeResult::getFullNatEnabled()const
+{
+	return fullNatEnabled_;
+}
+
+std::vector<std::string> DescribeLoadBalancerUDPListenerAttributeResult::getAclIds()const
+{
+	return aclIds_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckType()const
+{
+	return healthCheckType_;
+}
+

slb/src/model/DescribeLoadBalancersRequest.cc

@@ -19,21 +19,12 @@
 using AlibabaCloud::Slb::Model::DescribeLoadBalancersRequest;
 
 DescribeLoadBalancersRequest::DescribeLoadBalancersRequest()
-    : RpcServiceRequest("slb", "2013-02-21", "DescribeLoadBalancers") {
+    : RpcServiceRequest("slb", "2014-05-15", "DescribeLoadBalancers") {
   setMethod(HttpRequest::Method::Post);
 }
 
 DescribeLoadBalancersRequest::~DescribeLoadBalancersRequest() {}
 
-std::string DescribeLoadBalancersRequest::getAccess_key_id() const {
-  return access_key_id_;
-}
-
-void DescribeLoadBalancersRequest::setAccess_key_id(const std::string &access_key_id) {
-  access_key_id_ = access_key_id;
-  setParameter(std::string("access_key_id"), access_key_id);
-}
-
 long DescribeLoadBalancersRequest::getResourceOwnerId() const {
   return resourceOwnerId_;
 }
@@ -52,6 +43,15 @@ void DescribeLoadBalancersRequest::setNetworkType(const std::string &networkType
   setParameter(std::string("NetworkType"), networkType);
 }
 
+std::string DescribeLoadBalancersRequest::getAddressIPVersion() const {
+  return addressIPVersion_;
+}
+
+void DescribeLoadBalancersRequest::setAddressIPVersion(const std::string &addressIPVersion) {
+  addressIPVersion_ = addressIPVersion;
+  setParameter(std::string("AddressIPVersion"), addressIPVersion);
+}
+
 std::string DescribeLoadBalancersRequest::getMasterZoneId() const {
   return masterZoneId_;
 }
@@ -61,24 +61,6 @@ void DescribeLoadBalancersRequest::setMasterZoneId(const std::string &masterZone
   setParameter(std::string("MasterZoneId"), masterZoneId);
 }
 
-int DescribeLoadBalancersRequest::getPageNumber() const {
-  return pageNumber_;
-}
-
-void DescribeLoadBalancersRequest::setPageNumber(int pageNumber) {
-  pageNumber_ = pageNumber;
-  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
-}
-
-std::string DescribeLoadBalancersRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void DescribeLoadBalancersRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
 std::string DescribeLoadBalancersRequest::getResourceGroupId() const {
   return resourceGroupId_;
 }
@@ -97,33 +79,6 @@ void DescribeLoadBalancersRequest::setLoadBalancerName(const std::string &loadBa
   setParameter(std::string("LoadBalancerName"), loadBalancerName);
 }
 
-std::string DescribeLoadBalancersRequest::getRegionId() const {
-  return regionId_;
-}
-
-void DescribeLoadBalancersRequest::setRegionId(const std::string &regionId) {
-  regionId_ = regionId;
-  setParameter(std::string("RegionId"), regionId);
-}
-
-int DescribeLoadBalancersRequest::getPageSize() const {
-  return pageSize_;
-}
-
-void DescribeLoadBalancersRequest::setPageSize(int pageSize) {
-  pageSize_ = pageSize;
-  setParameter(std::string("PageSize"), std::to_string(pageSize));
-}
-
-std::string DescribeLoadBalancersRequest::getAddressType() const {
-  return addressType_;
-}
-
-void DescribeLoadBalancersRequest::setAddressType(const std::string &addressType) {
-  addressType_ = addressType;
-  setParameter(std::string("AddressType"), addressType);
-}
-
 std::string DescribeLoadBalancersRequest::getSlaveZoneId() const {
   return slaveZoneId_;
 }
@@ -133,31 +88,18 @@ void DescribeLoadBalancersRequest::setSlaveZoneId(const std::string &slaveZoneId
   setParameter(std::string("SlaveZoneId"), slaveZoneId);
 }
 
-std::string DescribeLoadBalancersRequest::getAddress() const {
-  return address_;
+std::vector<DescribeLoadBalancersRequest::Tag> DescribeLoadBalancersRequest::getTag() const {
+  return tag_;
 }
 
-void DescribeLoadBalancersRequest::setAddress(const std::string &address) {
-  address_ = address;
-  setParameter(std::string("Address"), address);
-}
-
-std::string DescribeLoadBalancersRequest::getResourceOwnerAccount() const {
-  return resourceOwnerAccount_;
-}
-
-void DescribeLoadBalancersRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
-  resourceOwnerAccount_ = resourceOwnerAccount;
-  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
-}
-
-std::string DescribeLoadBalancersRequest::getOwnerAccount() const {
-  return ownerAccount_;
-}
-
-void DescribeLoadBalancersRequest::setOwnerAccount(const std::string &ownerAccount) {
-  ownerAccount_ = ownerAccount;
-  setParameter(std::string("OwnerAccount"), ownerAccount);
+void DescribeLoadBalancersRequest::setTag(const std::vector<DescribeLoadBalancersRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
 }
 
 long DescribeLoadBalancersRequest::getOwnerId() const {
@@ -223,6 +165,132 @@ void DescribeLoadBalancersRequest::setInternetChargeType(const std::string &inte
   setParameter(std::string("InternetChargeType"), internetChargeType);
 }
 
+std::string DescribeLoadBalancersRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void DescribeLoadBalancersRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+bool DescribeLoadBalancersRequest::getSupportPrivateLink() const {
+  return supportPrivateLink_;
+}
+
+void DescribeLoadBalancersRequest::setSupportPrivateLink(bool supportPrivateLink) {
+  supportPrivateLink_ = supportPrivateLink;
+  setParameter(std::string("SupportPrivateLink"), supportPrivateLink ? "true" : "false");
+}
+
+int DescribeLoadBalancersRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeLoadBalancersRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string DescribeLoadBalancersRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeLoadBalancersRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+int DescribeLoadBalancersRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeLoadBalancersRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string DescribeLoadBalancersRequest::getAddressType() const {
+  return addressType_;
+}
+
+void DescribeLoadBalancersRequest::setAddressType(const std::string &addressType) {
+  addressType_ = addressType;
+  setParameter(std::string("AddressType"), addressType);
+}
+
+std::string DescribeLoadBalancersRequest::getInstanceChargeType() const {
+  return instanceChargeType_;
+}
+
+void DescribeLoadBalancersRequest::setInstanceChargeType(const std::string &instanceChargeType) {
+  instanceChargeType_ = instanceChargeType;
+  setParameter(std::string("InstanceChargeType"), instanceChargeType);
+}
+
+std::string DescribeLoadBalancersRequest::getFuzzy() const {
+  return fuzzy_;
+}
+
+void DescribeLoadBalancersRequest::setFuzzy(const std::string &fuzzy) {
+  fuzzy_ = fuzzy;
+  setParameter(std::string("Fuzzy"), fuzzy);
+}
+
+std::string DescribeLoadBalancersRequest::getBusinessStatus() const {
+  return businessStatus_;
+}
+
+void DescribeLoadBalancersRequest::setBusinessStatus(const std::string &businessStatus) {
+  businessStatus_ = businessStatus;
+  setParameter(std::string("BusinessStatus"), businessStatus);
+}
+
+std::string DescribeLoadBalancersRequest::getAddress() const {
+  return address_;
+}
+
+void DescribeLoadBalancersRequest::setAddress(const std::string &address) {
+  address_ = address;
+  setParameter(std::string("Address"), address);
+}
+
+std::string DescribeLoadBalancersRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DescribeLoadBalancersRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+bool DescribeLoadBalancersRequest::getFilterByTagOrName() const {
+  return filterByTagOrName_;
+}
+
+void DescribeLoadBalancersRequest::setFilterByTagOrName(bool filterByTagOrName) {
+  filterByTagOrName_ = filterByTagOrName;
+  setParameter(std::string("FilterByTagOrName"), filterByTagOrName ? "true" : "false");
+}
+
+std::string DescribeLoadBalancersRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DescribeLoadBalancersRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::string DescribeLoadBalancersRequest::getLoadBalancerStatus() const {
+  return loadBalancerStatus_;
+}
+
+void DescribeLoadBalancersRequest::setLoadBalancerStatus(const std::string &loadBalancerStatus) {
+  loadBalancerStatus_ = loadBalancerStatus;
+  setParameter(std::string("LoadBalancerStatus"), loadBalancerStatus);
+}
+
 std::string DescribeLoadBalancersRequest::getVpcId() const {
   return vpcId_;
 }

slb/src/model/DescribeLoadBalancersResult.cc

@@ -47,36 +47,75 @@ void DescribeLoadBalancersResult::parse(const std::string &payload)
 			loadBalancersObject.vpcId = valueLoadBalancersLoadBalancer["VpcId"].asString();
 		if(!valueLoadBalancersLoadBalancer["CreateTimeStamp"].isNull())
 			loadBalancersObject.createTimeStamp = std::stol(valueLoadBalancersLoadBalancer["CreateTimeStamp"].asString());
-		if(!valueLoadBalancersLoadBalancer["CreateTime"].isNull())
-			loadBalancersObject.createTime = valueLoadBalancersLoadBalancer["CreateTime"].asString();
 		if(!valueLoadBalancersLoadBalancer["LoadBalancerId"].isNull())
 			loadBalancersObject.loadBalancerId = valueLoadBalancersLoadBalancer["LoadBalancerId"].asString();
+		if(!valueLoadBalancersLoadBalancer["CreateTime"].isNull())
+			loadBalancersObject.createTime = valueLoadBalancersLoadBalancer["CreateTime"].asString();
 		if(!valueLoadBalancersLoadBalancer["PayType"].isNull())
 			loadBalancersObject.payType = valueLoadBalancersLoadBalancer["PayType"].asString();
 		if(!valueLoadBalancersLoadBalancer["AddressType"].isNull())
 			loadBalancersObject.addressType = valueLoadBalancersLoadBalancer["AddressType"].asString();
 		if(!valueLoadBalancersLoadBalancer["NetworkType"].isNull())
 			loadBalancersObject.networkType = valueLoadBalancersLoadBalancer["NetworkType"].asString();
-		if(!valueLoadBalancersLoadBalancer["RegionId"].isNull())
-			loadBalancersObject.regionId = valueLoadBalancersLoadBalancer["RegionId"].asString();
-		if(!valueLoadBalancersLoadBalancer["VSwitchId"].isNull())
-			loadBalancersObject.vSwitchId = valueLoadBalancersLoadBalancer["VSwitchId"].asString();
-		if(!valueLoadBalancersLoadBalancer["LoadBalancerStatus"].isNull())
-			loadBalancersObject.loadBalancerStatus = valueLoadBalancersLoadBalancer["LoadBalancerStatus"].asString();
+		if(!valueLoadBalancersLoadBalancer["ServiceManagedMode"].isNull())
+			loadBalancersObject.serviceManagedMode = valueLoadBalancersLoadBalancer["ServiceManagedMode"].asString();
+		if(!valueLoadBalancersLoadBalancer["SpecBpsFlag"].isNull())
+			loadBalancersObject.specBpsFlag = valueLoadBalancersLoadBalancer["SpecBpsFlag"].asString() == "true";
+		if(!valueLoadBalancersLoadBalancer["AddressIPVersion"].isNull())
+			loadBalancersObject.addressIPVersion = valueLoadBalancersLoadBalancer["AddressIPVersion"].asString();
 		if(!valueLoadBalancersLoadBalancer["LoadBalancerName"].isNull())
 			loadBalancersObject.loadBalancerName = valueLoadBalancersLoadBalancer["LoadBalancerName"].asString();
-		if(!valueLoadBalancersLoadBalancer["ResourceGroupId"].isNull())
-			loadBalancersObject.resourceGroupId = valueLoadBalancersLoadBalancer["ResourceGroupId"].asString();
-		if(!valueLoadBalancersLoadBalancer["InternetChargeType"].isNull())
-			loadBalancersObject.internetChargeType = valueLoadBalancersLoadBalancer["InternetChargeType"].asString();
+		if(!valueLoadBalancersLoadBalancer["Bandwidth"].isNull())
+			loadBalancersObject.bandwidth = std::stoi(valueLoadBalancersLoadBalancer["Bandwidth"].asString());
 		if(!valueLoadBalancersLoadBalancer["Address"].isNull())
 			loadBalancersObject.address = valueLoadBalancersLoadBalancer["Address"].asString();
 		if(!valueLoadBalancersLoadBalancer["SlaveZoneId"].isNull())
 			loadBalancersObject.slaveZoneId = valueLoadBalancersLoadBalancer["SlaveZoneId"].asString();
-		if(!valueLoadBalancersLoadBalancer["RegionIdAlias"].isNull())
-			loadBalancersObject.regionIdAlias = valueLoadBalancersLoadBalancer["RegionIdAlias"].asString();
 		if(!valueLoadBalancersLoadBalancer["MasterZoneId"].isNull())
 			loadBalancersObject.masterZoneId = valueLoadBalancersLoadBalancer["MasterZoneId"].asString();
+		if(!valueLoadBalancersLoadBalancer["InternetChargeTypeAlias"].isNull())
+			loadBalancersObject.internetChargeTypeAlias = valueLoadBalancersLoadBalancer["InternetChargeTypeAlias"].asString();
+		if(!valueLoadBalancersLoadBalancer["LoadBalancerSpec"].isNull())
+			loadBalancersObject.loadBalancerSpec = valueLoadBalancersLoadBalancer["LoadBalancerSpec"].asString();
+		if(!valueLoadBalancersLoadBalancer["SpecType"].isNull())
+			loadBalancersObject.specType = valueLoadBalancersLoadBalancer["SpecType"].asString();
+		if(!valueLoadBalancersLoadBalancer["RegionId"].isNull())
+			loadBalancersObject.regionId = valueLoadBalancersLoadBalancer["RegionId"].asString();
+		if(!valueLoadBalancersLoadBalancer["ModificationProtectionReason"].isNull())
+			loadBalancersObject.modificationProtectionReason = valueLoadBalancersLoadBalancer["ModificationProtectionReason"].asString();
+		if(!valueLoadBalancersLoadBalancer["ModificationProtectionStatus"].isNull())
+			loadBalancersObject.modificationProtectionStatus = valueLoadBalancersLoadBalancer["ModificationProtectionStatus"].asString();
+		if(!valueLoadBalancersLoadBalancer["VSwitchId"].isNull())
+			loadBalancersObject.vSwitchId = valueLoadBalancersLoadBalancer["VSwitchId"].asString();
+		if(!valueLoadBalancersLoadBalancer["LoadBalancerStatus"].isNull())
+			loadBalancersObject.loadBalancerStatus = valueLoadBalancersLoadBalancer["LoadBalancerStatus"].asString();
+		if(!valueLoadBalancersLoadBalancer["ResourceGroupId"].isNull())
+			loadBalancersObject.resourceGroupId = valueLoadBalancersLoadBalancer["ResourceGroupId"].asString();
+		if(!valueLoadBalancersLoadBalancer["InternetChargeType"].isNull())
+			loadBalancersObject.internetChargeType = valueLoadBalancersLoadBalancer["InternetChargeType"].asString();
+		if(!valueLoadBalancersLoadBalancer["BusinessStatus"].isNull())
+			loadBalancersObject.businessStatus = valueLoadBalancersLoadBalancer["BusinessStatus"].asString();
+		if(!valueLoadBalancersLoadBalancer["DeleteProtection"].isNull())
+			loadBalancersObject.deleteProtection = valueLoadBalancersLoadBalancer["DeleteProtection"].asString();
+		if(!valueLoadBalancersLoadBalancer["RegionIdAlias"].isNull())
+			loadBalancersObject.regionIdAlias = valueLoadBalancersLoadBalancer["RegionIdAlias"].asString();
+		if(!valueLoadBalancersLoadBalancer["InstanceChargeType"].isNull())
+			loadBalancersObject.instanceChargeType = valueLoadBalancersLoadBalancer["InstanceChargeType"].asString();
+		if(!valueLoadBalancersLoadBalancer["ServiceManagedReason"].isNull())
+			loadBalancersObject.serviceManagedReason = valueLoadBalancersLoadBalancer["ServiceManagedReason"].asString();
+		auto allTagsNode = valueLoadBalancersLoadBalancer["Tags"]["Tag"];
+		for (auto valueLoadBalancersLoadBalancerTagsTag : allTagsNode)
+		{
+			LoadBalancer::Tag tagsObject;
+			if(!valueLoadBalancersLoadBalancerTagsTag["TagValue"].isNull())
+				tagsObject.tagValue = valueLoadBalancersLoadBalancerTagsTag["TagValue"].asString();
+			if(!valueLoadBalancersLoadBalancerTagsTag["TagKey"].isNull())
+				tagsObject.tagKey = valueLoadBalancersLoadBalancerTagsTag["TagKey"].asString();
+			loadBalancersObject.tags.push_back(tagsObject);
+		}
+		auto allIneffectiveOrderList = value["IneffectiveOrderList"]["IneffectiveOrder"];
+		for (auto value : allIneffectiveOrderList)
+			loadBalancersObject.ineffectiveOrderList.push_back(value.asString());
 		loadBalancers_.push_back(loadBalancersObject);
 	}
 	if(!value["PageNumber"].isNull())

slb/src/model/DescribeMasterSlaveServerGroupAttributeRequest.cc

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

slb/src/model/DescribeMasterSlaveServerGroupAttributeResult.cc

@@ -0,0 +1,121 @@
+/*
+ * 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/DescribeMasterSlaveServerGroupAttributeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DescribeMasterSlaveServerGroupAttributeResult::DescribeMasterSlaveServerGroupAttributeResult() :
+	ServiceResult()
+{}
+
+DescribeMasterSlaveServerGroupAttributeResult::DescribeMasterSlaveServerGroupAttributeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeMasterSlaveServerGroupAttributeResult::~DescribeMasterSlaveServerGroupAttributeResult()
+{}
+
+void DescribeMasterSlaveServerGroupAttributeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTagsNode = value["Tags"]["Tag"];
+	for (auto valueTagsTag : allTagsNode)
+	{
+		Tag tagsObject;
+		if(!valueTagsTag["TagKey"].isNull())
+			tagsObject.tagKey = valueTagsTag["TagKey"].asString();
+		if(!valueTagsTag["TagValue"].isNull())
+			tagsObject.tagValue = valueTagsTag["TagValue"].asString();
+		tags_.push_back(tagsObject);
+	}
+	auto allMasterSlaveBackendServersNode = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
+	for (auto valueMasterSlaveBackendServersMasterSlaveBackendServer : allMasterSlaveBackendServersNode)
+	{
+		MasterSlaveBackendServer masterSlaveBackendServersObject;
+		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["VpcId"].isNull())
+			masterSlaveBackendServersObject.vpcId = valueMasterSlaveBackendServersMasterSlaveBackendServer["VpcId"].asString();
+		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Type"].isNull())
+			masterSlaveBackendServersObject.type = valueMasterSlaveBackendServersMasterSlaveBackendServer["Type"].asString();
+		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Weight"].isNull())
+			masterSlaveBackendServersObject.weight = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["Weight"].asString());
+		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Description"].isNull())
+			masterSlaveBackendServersObject.description = valueMasterSlaveBackendServersMasterSlaveBackendServer["Description"].asString();
+		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerIp"].isNull())
+			masterSlaveBackendServersObject.serverIp = valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerIp"].asString();
+		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Port"].isNull())
+			masterSlaveBackendServersObject.port = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["Port"].asString());
+		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerId"].isNull())
+			masterSlaveBackendServersObject.serverId = valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerId"].asString();
+		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerType"].isNull())
+			masterSlaveBackendServersObject.serverType = valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerType"].asString();
+		masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
+	}
+	if(!value["ServiceManagedMode"].isNull())
+		serviceManagedMode_ = value["ServiceManagedMode"].asString();
+	if(!value["LoadBalancerId"].isNull())
+		loadBalancerId_ = value["LoadBalancerId"].asString();
+	if(!value["MasterSlaveServerGroupName"].isNull())
+		masterSlaveServerGroupName_ = value["MasterSlaveServerGroupName"].asString();
+	if(!value["MasterSlaveServerGroupId"].isNull())
+		masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+
+}
+
+std::string DescribeMasterSlaveServerGroupAttributeResult::getServiceManagedMode()const
+{
+	return serviceManagedMode_;
+}
+
+std::string DescribeMasterSlaveServerGroupAttributeResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+std::string DescribeMasterSlaveServerGroupAttributeResult::getMasterSlaveServerGroupId()const
+{
+	return masterSlaveServerGroupId_;
+}
+
+std::string DescribeMasterSlaveServerGroupAttributeResult::getLoadBalancerId()const
+{
+	return loadBalancerId_;
+}
+
+std::string DescribeMasterSlaveServerGroupAttributeResult::getMasterSlaveServerGroupName()const
+{
+	return masterSlaveServerGroupName_;
+}
+
+std::vector<DescribeMasterSlaveServerGroupAttributeResult::MasterSlaveBackendServer> DescribeMasterSlaveServerGroupAttributeResult::getMasterSlaveBackendServers()const
+{
+	return masterSlaveBackendServers_;
+}
+
+std::vector<DescribeMasterSlaveServerGroupAttributeResult::Tag> DescribeMasterSlaveServerGroupAttributeResult::getTags()const
+{
+	return tags_;
+}
+

slb/src/model/DescribeMasterSlaveServerGroupsRequest.cc

@@ -0,0 +1,131 @@
+/*
+ * 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/DescribeMasterSlaveServerGroupsRequest.h>
+
+using AlibabaCloud::Slb::Model::DescribeMasterSlaveServerGroupsRequest;
+
+DescribeMasterSlaveServerGroupsRequest::DescribeMasterSlaveServerGroupsRequest()
+    : RpcServiceRequest("slb", "2014-05-15", "DescribeMasterSlaveServerGroups") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeMasterSlaveServerGroupsRequest::~DescribeMasterSlaveServerGroupsRequest() {}
+
+std::string DescribeMasterSlaveServerGroupsRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void DescribeMasterSlaveServerGroupsRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+long DescribeMasterSlaveServerGroupsRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DescribeMasterSlaveServerGroupsRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+bool DescribeMasterSlaveServerGroupsRequest::getIncludeListener() const {
+  return includeListener_;
+}
+
+void DescribeMasterSlaveServerGroupsRequest::setIncludeListener(bool includeListener) {
+  includeListener_ = includeListener;
+  setParameter(std::string("IncludeListener"), includeListener ? "true" : "false");
+}
+
+std::string DescribeMasterSlaveServerGroupsRequest::getDescription() const {
+  return description_;
+}
+
+void DescribeMasterSlaveServerGroupsRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+std::string DescribeMasterSlaveServerGroupsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeMasterSlaveServerGroupsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::vector<DescribeMasterSlaveServerGroupsRequest::Tag> DescribeMasterSlaveServerGroupsRequest::getTag() const {
+  return tag_;
+}
+
+void DescribeMasterSlaveServerGroupsRequest::setTag(const std::vector<DescribeMasterSlaveServerGroupsRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
+std::string DescribeMasterSlaveServerGroupsRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DescribeMasterSlaveServerGroupsRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DescribeMasterSlaveServerGroupsRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DescribeMasterSlaveServerGroupsRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DescribeMasterSlaveServerGroupsRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeMasterSlaveServerGroupsRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DescribeMasterSlaveServerGroupsRequest::getTags() const {
+  return tags_;
+}
+
+void DescribeMasterSlaveServerGroupsRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+
+std::string DescribeMasterSlaveServerGroupsRequest::getLoadBalancerId() const {
+  return loadBalancerId_;
+}
+
+void DescribeMasterSlaveServerGroupsRequest::setLoadBalancerId(const std::string &loadBalancerId) {
+  loadBalancerId_ = loadBalancerId;
+  setParameter(std::string("LoadBalancerId"), loadBalancerId);
+}
+

slb/src/model/DescribeMasterSlaveServerGroupsResult.cc

@@ -0,0 +1,84 @@
+/*
+ * 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/DescribeMasterSlaveServerGroupsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DescribeMasterSlaveServerGroupsResult::DescribeMasterSlaveServerGroupsResult() :
+	ServiceResult()
+{}
+
+DescribeMasterSlaveServerGroupsResult::DescribeMasterSlaveServerGroupsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeMasterSlaveServerGroupsResult::~DescribeMasterSlaveServerGroupsResult()
+{}
+
+void DescribeMasterSlaveServerGroupsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allMasterSlaveServerGroupsNode = value["MasterSlaveServerGroups"]["MasterSlaveServerGroup"];
+	for (auto valueMasterSlaveServerGroupsMasterSlaveServerGroup : allMasterSlaveServerGroupsNode)
+	{
+		MasterSlaveServerGroup masterSlaveServerGroupsObject;
+		if(!valueMasterSlaveServerGroupsMasterSlaveServerGroup["ServiceManagedMode"].isNull())
+			masterSlaveServerGroupsObject.serviceManagedMode = valueMasterSlaveServerGroupsMasterSlaveServerGroup["ServiceManagedMode"].asString();
+		if(!valueMasterSlaveServerGroupsMasterSlaveServerGroup["MasterSlaveServerGroupId"].isNull())
+			masterSlaveServerGroupsObject.masterSlaveServerGroupId = valueMasterSlaveServerGroupsMasterSlaveServerGroup["MasterSlaveServerGroupId"].asString();
+		if(!valueMasterSlaveServerGroupsMasterSlaveServerGroup["MasterSlaveServerGroupName"].isNull())
+			masterSlaveServerGroupsObject.masterSlaveServerGroupName = valueMasterSlaveServerGroupsMasterSlaveServerGroup["MasterSlaveServerGroupName"].asString();
+		if(!valueMasterSlaveServerGroupsMasterSlaveServerGroup["CreateTime"].isNull())
+			masterSlaveServerGroupsObject.createTime = valueMasterSlaveServerGroupsMasterSlaveServerGroup["CreateTime"].asString();
+		auto allTagsNode = valueMasterSlaveServerGroupsMasterSlaveServerGroup["Tags"]["Tag"];
+		for (auto valueMasterSlaveServerGroupsMasterSlaveServerGroupTagsTag : allTagsNode)
+		{
+			MasterSlaveServerGroup::Tag tagsObject;
+			if(!valueMasterSlaveServerGroupsMasterSlaveServerGroupTagsTag["TagKey"].isNull())
+				tagsObject.tagKey = valueMasterSlaveServerGroupsMasterSlaveServerGroupTagsTag["TagKey"].asString();
+			if(!valueMasterSlaveServerGroupsMasterSlaveServerGroupTagsTag["TagValue"].isNull())
+				tagsObject.tagValue = valueMasterSlaveServerGroupsMasterSlaveServerGroupTagsTag["TagValue"].asString();
+			masterSlaveServerGroupsObject.tags.push_back(tagsObject);
+		}
+		auto associatedObjectsNode = value["AssociatedObjects"];
+		auto allListenersNode = associatedObjectsNode["Listeners"]["Listener"];
+		for (auto associatedObjectsNodeListenersListener : allListenersNode)
+		{
+			MasterSlaveServerGroup::AssociatedObjects::Listener listenerObject;
+			if(!associatedObjectsNodeListenersListener["Port"].isNull())
+				listenerObject.port = std::stoi(associatedObjectsNodeListenersListener["Port"].asString());
+			if(!associatedObjectsNodeListenersListener["Protocol"].isNull())
+				listenerObject.protocol = associatedObjectsNodeListenersListener["Protocol"].asString();
+			masterSlaveServerGroupsObject.associatedObjects.listeners.push_back(listenerObject);
+		}
+		masterSlaveServerGroups_.push_back(masterSlaveServerGroupsObject);
+	}
+
+}
+
+std::vector<DescribeMasterSlaveServerGroupsResult::MasterSlaveServerGroup> DescribeMasterSlaveServerGroupsResult::getMasterSlaveServerGroups()const
+{
+	return masterSlaveServerGroups_;
+}
+

slb/src/model/DescribeRegionsRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::Slb::Model::DescribeRegionsRequest;
 
 DescribeRegionsRequest::DescribeRegionsRequest()
-    : RpcServiceRequest("slb", "2013-02-21", "DescribeRegions") {
+    : RpcServiceRequest("slb", "2014-05-15", "DescribeRegions") {
   setMethod(HttpRequest::Method::Post);
 }
 
@@ -43,6 +43,15 @@ void DescribeRegionsRequest::setResourceOwnerId(long resourceOwnerId) {
   setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
+std::string DescribeRegionsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeRegionsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
 std::string DescribeRegionsRequest::getResourceOwnerAccount() const {
   return resourceOwnerAccount_;
 }
@@ -70,15 +79,6 @@ void DescribeRegionsRequest::setOwnerId(long ownerId) {
   setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-std::string DescribeRegionsRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void DescribeRegionsRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
 std::string DescribeRegionsRequest::getTags() const {
   return tags_;
 }
@@ -88,3 +88,12 @@ void DescribeRegionsRequest::setTags(const std::string &tags) {
   setParameter(std::string("Tags"), tags);
 }
 
+std::string DescribeRegionsRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void DescribeRegionsRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+

slb/src/model/DescribeRegionsResult.cc

@@ -43,6 +43,8 @@ void DescribeRegionsResult::parse(const std::string &payload)
 	for (auto valueRegionsRegion : allRegionsNode)
 	{
 		Region regionsObject;
+		if(!valueRegionsRegion["RegionEndpoint"].isNull())
+			regionsObject.regionEndpoint = valueRegionsRegion["RegionEndpoint"].asString();
 		if(!valueRegionsRegion["LocalName"].isNull())
 			regionsObject.localName = valueRegionsRegion["LocalName"].asString();
 		if(!valueRegionsRegion["RegionId"].isNull())

slb/src/model/DescribeRuleAttributeRequest.cc

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

slb/src/model/DescribeRuleAttributeResult.cc

@@ -0,0 +1,205 @@
+/*
+ * 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/DescribeRuleAttributeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DescribeRuleAttributeResult::DescribeRuleAttributeResult() :
+	ServiceResult()
+{}
+
+DescribeRuleAttributeResult::DescribeRuleAttributeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeRuleAttributeResult::~DescribeRuleAttributeResult()
+{}
+
+void DescribeRuleAttributeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["VServerGroupId"].isNull())
+		vServerGroupId_ = value["VServerGroupId"].asString();
+	if(!value["Cookie"].isNull())
+		cookie_ = value["Cookie"].asString();
+	if(!value["LoadBalancerId"].isNull())
+		loadBalancerId_ = value["LoadBalancerId"].asString();
+	if(!value["RuleId"].isNull())
+		ruleId_ = value["RuleId"].asString();
+	if(!value["ServiceManagedMode"].isNull())
+		serviceManagedMode_ = value["ServiceManagedMode"].asString();
+	if(!value["HealthCheckConnectPort"].isNull())
+		healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
+	if(!value["HealthCheckTimeout"].isNull())
+		healthCheckTimeout_ = std::stoi(value["HealthCheckTimeout"].asString());
+	if(!value["CookieTimeout"].isNull())
+		cookieTimeout_ = std::stoi(value["CookieTimeout"].asString());
+	if(!value["HealthCheckDomain"].isNull())
+		healthCheckDomain_ = value["HealthCheckDomain"].asString();
+	if(!value["UnhealthyThreshold"].isNull())
+		unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
+	if(!value["HealthCheckHttpCode"].isNull())
+		healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
+	if(!value["Domain"].isNull())
+		domain_ = value["Domain"].asString();
+	if(!value["ListenerPort"].isNull())
+		listenerPort_ = value["ListenerPort"].asString();
+	if(!value["Url"].isNull())
+		url_ = value["Url"].asString();
+	if(!value["HealthCheckInterval"].isNull())
+		healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
+	if(!value["HealthCheckURI"].isNull())
+		healthCheckURI_ = value["HealthCheckURI"].asString();
+	if(!value["RuleName"].isNull())
+		ruleName_ = value["RuleName"].asString();
+	if(!value["StickySessionType"].isNull())
+		stickySessionType_ = value["StickySessionType"].asString();
+	if(!value["Scheduler"].isNull())
+		scheduler_ = value["Scheduler"].asString();
+	if(!value["ListenerSync"].isNull())
+		listenerSync_ = value["ListenerSync"].asString();
+	if(!value["HealthyThreshold"].isNull())
+		healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
+	if(!value["StickySession"].isNull())
+		stickySession_ = value["StickySession"].asString();
+	if(!value["HealthCheck"].isNull())
+		healthCheck_ = value["HealthCheck"].asString();
+
+}
+
+std::string DescribeRuleAttributeResult::getCookie()const
+{
+	return cookie_;
+}
+
+int DescribeRuleAttributeResult::getCookieTimeout()const
+{
+	return cookieTimeout_;
+}
+
+std::string DescribeRuleAttributeResult::getVServerGroupId()const
+{
+	return vServerGroupId_;
+}
+
+std::string DescribeRuleAttributeResult::getListenerPort()const
+{
+	return listenerPort_;
+}
+
+int DescribeRuleAttributeResult::getHealthCheckInterval()const
+{
+	return healthCheckInterval_;
+}
+
+int DescribeRuleAttributeResult::getUnhealthyThreshold()const
+{
+	return unhealthyThreshold_;
+}
+
+std::string DescribeRuleAttributeResult::getHealthCheckURI()const
+{
+	return healthCheckURI_;
+}
+
+std::string DescribeRuleAttributeResult::getScheduler()const
+{
+	return scheduler_;
+}
+
+std::string DescribeRuleAttributeResult::getRuleId()const
+{
+	return ruleId_;
+}
+
+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_;
+}
+
+std::string DescribeRuleAttributeResult::getServiceManagedMode()const
+{
+	return serviceManagedMode_;
+}
+
+int DescribeRuleAttributeResult::getHealthyThreshold()const
+{
+	return healthyThreshold_;
+}
+
+std::string DescribeRuleAttributeResult::getHealthCheckDomain()const
+{
+	return healthCheckDomain_;
+}
+
+std::string DescribeRuleAttributeResult::getListenerSync()const
+{
+	return listenerSync_;
+}
+
+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/DescribeRulesRequest.cc

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

slb/src/model/DescribeRulesResult.cc

@@ -0,0 +1,97 @@
+/*
+ * 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/DescribeRulesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DescribeRulesResult::DescribeRulesResult() :
+	ServiceResult()
+{}
+
+DescribeRulesResult::DescribeRulesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeRulesResult::~DescribeRulesResult()
+{}
+
+void DescribeRulesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allRulesNode = value["Rules"]["Rule"];
+	for (auto valueRulesRule : allRulesNode)
+	{
+		Rule rulesObject;
+		if(!valueRulesRule["HealthCheckHttpCode"].isNull())
+			rulesObject.healthCheckHttpCode = valueRulesRule["HealthCheckHttpCode"].asString();
+		if(!valueRulesRule["VServerGroupId"].isNull())
+			rulesObject.vServerGroupId = valueRulesRule["VServerGroupId"].asString();
+		if(!valueRulesRule["Domain"].isNull())
+			rulesObject.domain = valueRulesRule["Domain"].asString();
+		if(!valueRulesRule["Cookie"].isNull())
+			rulesObject.cookie = valueRulesRule["Cookie"].asString();
+		if(!valueRulesRule["HealthCheckInterval"].isNull())
+			rulesObject.healthCheckInterval = std::stoi(valueRulesRule["HealthCheckInterval"].asString());
+		if(!valueRulesRule["Url"].isNull())
+			rulesObject.url = valueRulesRule["Url"].asString();
+		if(!valueRulesRule["HealthCheckURI"].isNull())
+			rulesObject.healthCheckURI = valueRulesRule["HealthCheckURI"].asString();
+		if(!valueRulesRule["StickySessionType"].isNull())
+			rulesObject.stickySessionType = valueRulesRule["StickySessionType"].asString();
+		if(!valueRulesRule["RuleName"].isNull())
+			rulesObject.ruleName = valueRulesRule["RuleName"].asString();
+		if(!valueRulesRule["RuleId"].isNull())
+			rulesObject.ruleId = valueRulesRule["RuleId"].asString();
+		if(!valueRulesRule["ServiceManagedMode"].isNull())
+			rulesObject.serviceManagedMode = valueRulesRule["ServiceManagedMode"].asString();
+		if(!valueRulesRule["HealthCheckConnectPort"].isNull())
+			rulesObject.healthCheckConnectPort = std::stoi(valueRulesRule["HealthCheckConnectPort"].asString());
+		if(!valueRulesRule["Scheduler"].isNull())
+			rulesObject.scheduler = valueRulesRule["Scheduler"].asString();
+		if(!valueRulesRule["HealthCheckTimeout"].isNull())
+			rulesObject.healthCheckTimeout = std::stoi(valueRulesRule["HealthCheckTimeout"].asString());
+		if(!valueRulesRule["ListenerSync"].isNull())
+			rulesObject.listenerSync = valueRulesRule["ListenerSync"].asString();
+		if(!valueRulesRule["HealthyThreshold"].isNull())
+			rulesObject.healthyThreshold = std::stoi(valueRulesRule["HealthyThreshold"].asString());
+		if(!valueRulesRule["CookieTimeout"].isNull())
+			rulesObject.cookieTimeout = std::stoi(valueRulesRule["CookieTimeout"].asString());
+		if(!valueRulesRule["HealthCheckDomain"].isNull())
+			rulesObject.healthCheckDomain = valueRulesRule["HealthCheckDomain"].asString();
+		if(!valueRulesRule["UnhealthyThreshold"].isNull())
+			rulesObject.unhealthyThreshold = std::stoi(valueRulesRule["UnhealthyThreshold"].asString());
+		if(!valueRulesRule["StickySession"].isNull())
+			rulesObject.stickySession = valueRulesRule["StickySession"].asString();
+		if(!valueRulesRule["HealthCheck"].isNull())
+			rulesObject.healthCheck = valueRulesRule["HealthCheck"].asString();
+		rules_.push_back(rulesObject);
+	}
+
+}
+
+std::vector<DescribeRulesResult::Rule> DescribeRulesResult::getRules()const
+{
+	return rules_;
+}
+

slb/src/model/DescribeServerCertificatesRequest.cc

@@ -0,0 +1,122 @@
+/*
+ * 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/DescribeServerCertificatesRequest.h>
+
+using AlibabaCloud::Slb::Model::DescribeServerCertificatesRequest;
+
+DescribeServerCertificatesRequest::DescribeServerCertificatesRequest()
+    : RpcServiceRequest("slb", "2014-05-15", "DescribeServerCertificates") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeServerCertificatesRequest::~DescribeServerCertificatesRequest() {}
+
+std::string DescribeServerCertificatesRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void DescribeServerCertificatesRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+long DescribeServerCertificatesRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DescribeServerCertificatesRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DescribeServerCertificatesRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void DescribeServerCertificatesRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
+std::string DescribeServerCertificatesRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeServerCertificatesRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::vector<DescribeServerCertificatesRequest::Tag> DescribeServerCertificatesRequest::getTag() const {
+  return tag_;
+}
+
+void DescribeServerCertificatesRequest::setTag(const std::vector<DescribeServerCertificatesRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
+std::string DescribeServerCertificatesRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DescribeServerCertificatesRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DescribeServerCertificatesRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DescribeServerCertificatesRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DescribeServerCertificatesRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeServerCertificatesRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DescribeServerCertificatesRequest::getServerCertificateId() const {
+  return serverCertificateId_;
+}
+
+void DescribeServerCertificatesRequest::setServerCertificateId(const std::string &serverCertificateId) {
+  serverCertificateId_ = serverCertificateId;
+  setParameter(std::string("ServerCertificateId"), serverCertificateId);
+}
+
+std::string DescribeServerCertificatesRequest::getTags() const {
+  return tags_;
+}
+
+void DescribeServerCertificatesRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+

slb/src/model/DescribeServerCertificatesResult.cc

@@ -0,0 +1,102 @@
+/*
+ * 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/DescribeServerCertificatesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+DescribeServerCertificatesResult::DescribeServerCertificatesResult() :
+	ServiceResult()
+{}
+
+DescribeServerCertificatesResult::DescribeServerCertificatesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeServerCertificatesResult::~DescribeServerCertificatesResult()
+{}
+
+void DescribeServerCertificatesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allServerCertificatesNode = value["ServerCertificates"]["ServerCertificate"];
+	for (auto valueServerCertificatesServerCertificate : allServerCertificatesNode)
+	{
+		ServerCertificate serverCertificatesObject;
+		if(!valueServerCertificatesServerCertificate["CreateTimeStamp"].isNull())
+			serverCertificatesObject.createTimeStamp = std::stol(valueServerCertificatesServerCertificate["CreateTimeStamp"].asString());
+		if(!valueServerCertificatesServerCertificate["AliCloudCertificateName"].isNull())
+			serverCertificatesObject.aliCloudCertificateName = valueServerCertificatesServerCertificate["AliCloudCertificateName"].asString();
+		if(!valueServerCertificatesServerCertificate["StandardType"].isNull())
+			serverCertificatesObject.standardType = valueServerCertificatesServerCertificate["StandardType"].asString();
+		if(!valueServerCertificatesServerCertificate["ExpireTime"].isNull())
+			serverCertificatesObject.expireTime = valueServerCertificatesServerCertificate["ExpireTime"].asString();
+		if(!valueServerCertificatesServerCertificate["EncryptionKeyLength"].isNull())
+			serverCertificatesObject.encryptionKeyLength = std::stoi(valueServerCertificatesServerCertificate["EncryptionKeyLength"].asString());
+		if(!valueServerCertificatesServerCertificate["CreateTime"].isNull())
+			serverCertificatesObject.createTime = valueServerCertificatesServerCertificate["CreateTime"].asString();
+		if(!valueServerCertificatesServerCertificate["ServerCertificateId"].isNull())
+			serverCertificatesObject.serverCertificateId = valueServerCertificatesServerCertificate["ServerCertificateId"].asString();
+		if(!valueServerCertificatesServerCertificate["ExpireTimeStamp"].isNull())
+			serverCertificatesObject.expireTimeStamp = std::stol(valueServerCertificatesServerCertificate["ExpireTimeStamp"].asString());
+		if(!valueServerCertificatesServerCertificate["RegionId"].isNull())
+			serverCertificatesObject.regionId = valueServerCertificatesServerCertificate["RegionId"].asString();
+		if(!valueServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
+			serverCertificatesObject.encryptionAlgorithm = valueServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
+		if(!valueServerCertificatesServerCertificate["ServerCertificateName"].isNull())
+			serverCertificatesObject.serverCertificateName = valueServerCertificatesServerCertificate["ServerCertificateName"].asString();
+		if(!valueServerCertificatesServerCertificate["Fingerprint"].isNull())
+			serverCertificatesObject.fingerprint = valueServerCertificatesServerCertificate["Fingerprint"].asString();
+		if(!valueServerCertificatesServerCertificate["CommonName"].isNull())
+			serverCertificatesObject.commonName = valueServerCertificatesServerCertificate["CommonName"].asString();
+		if(!valueServerCertificatesServerCertificate["ResourceGroupId"].isNull())
+			serverCertificatesObject.resourceGroupId = valueServerCertificatesServerCertificate["ResourceGroupId"].asString();
+		if(!valueServerCertificatesServerCertificate["RegionIdAlias"].isNull())
+			serverCertificatesObject.regionIdAlias = valueServerCertificatesServerCertificate["RegionIdAlias"].asString();
+		if(!valueServerCertificatesServerCertificate["IsAliCloudCertificate"].isNull())
+			serverCertificatesObject.isAliCloudCertificate = std::stoi(valueServerCertificatesServerCertificate["IsAliCloudCertificate"].asString());
+		if(!valueServerCertificatesServerCertificate["AliCloudCertificateId"].isNull())
+			serverCertificatesObject.aliCloudCertificateId = valueServerCertificatesServerCertificate["AliCloudCertificateId"].asString();
+		auto allTagsNode = valueServerCertificatesServerCertificate["Tags"]["Tag"];
+		for (auto valueServerCertificatesServerCertificateTagsTag : allTagsNode)
+		{
+			ServerCertificate::Tag tagsObject;
+			if(!valueServerCertificatesServerCertificateTagsTag["TagValue"].isNull())
+				tagsObject.tagValue = valueServerCertificatesServerCertificateTagsTag["TagValue"].asString();
+			if(!valueServerCertificatesServerCertificateTagsTag["TagKey"].isNull())
+				tagsObject.tagKey = valueServerCertificatesServerCertificateTagsTag["TagKey"].asString();
+			serverCertificatesObject.tags.push_back(tagsObject);
+		}
+		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_;
+}
+

slb/src/model/DescribeTagsRequest.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/DescribeTagsRequest.h>
+
+using AlibabaCloud::Slb::Model::DescribeTagsRequest;
+
+DescribeTagsRequest::DescribeTagsRequest()
+    : RpcServiceRequest("slb", "2014-05-15", "DescribeTags") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeTagsRequest::~DescribeTagsRequest() {}
+
+std::string DescribeTagsRequest::getAccess_key_id() const {
+  return access_key_id_;
+}
+
+void DescribeTagsRequest::setAccess_key_id(const std::string &access_key_id) {
+  access_key_id_ = access_key_id;
+  setParameter(std::string("access_key_id"), access_key_id);
+}
+
+long DescribeTagsRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DescribeTagsRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+int DescribeTagsRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeTagsRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string DescribeTagsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeTagsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+int DescribeTagsRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeTagsRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string DescribeTagsRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DescribeTagsRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DescribeTagsRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DescribeTagsRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+bool DescribeTagsRequest::getDistinctKey() const {
+  return distinctKey_;
+}
+
+void DescribeTagsRequest::setDistinctKey(bool distinctKey) {
+  distinctKey_ = distinctKey;
+  setParameter(std::string("DistinctKey"), distinctKey ? "true" : "false");
+}
+
+long DescribeTagsRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeTagsRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DescribeTagsRequest::getTags() const {
+  return tags_;
+}
+
+void DescribeTagsRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+
+std::string DescribeTagsRequest::getLoadBalancerId() const {
+  return loadBalancerId_;
+}
+
+void DescribeTagsRequest::setLoadBalancerId(const std::string &loadBalancerId) {
+  loadBalancerId_ = loadBalancerId;
+  setParameter(std::string("LoadBalancerId"), loadBalancerId);
+}
+