Generated 2016-04-28 for Vpc.

vpc/src/model/AddBandwidthPackageIpsRequest.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/vpc/model/AddBandwidthPackageIpsRequest.h>
-
-using AlibabaCloud::Vpc::Model::AddBandwidthPackageIpsRequest;
-
-AddBandwidthPackageIpsRequest::AddBandwidthPackageIpsRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "AddBandwidthPackageIps")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AddBandwidthPackageIpsRequest::~AddBandwidthPackageIpsRequest()
-{}
-
-long AddBandwidthPackageIpsRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
-}
-
-void AddBandwidthPackageIpsRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
-}
-
-std::string AddBandwidthPackageIpsRequest::getClientToken()const
-{
-	return clientToken_;
-}
-
-void AddBandwidthPackageIpsRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
-}
-
-std::string AddBandwidthPackageIpsRequest::getRegionId()const
-{
-	return regionId_;
-}
-
-void AddBandwidthPackageIpsRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
-}
-
-std::string AddBandwidthPackageIpsRequest::getBandwidthPackageId()const
-{
-	return bandwidthPackageId_;
-}
-
-void AddBandwidthPackageIpsRequest::setBandwidthPackageId(const std::string& bandwidthPackageId)
-{
-	bandwidthPackageId_ = bandwidthPackageId;
-	setParameter("BandwidthPackageId", bandwidthPackageId);
-}
-
-std::string AddBandwidthPackageIpsRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
-}
-
-void AddBandwidthPackageIpsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
-}
-
-std::string AddBandwidthPackageIpsRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
-}
-
-void AddBandwidthPackageIpsRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
-}
-
-long AddBandwidthPackageIpsRequest::getOwnerId()const
-{
-	return ownerId_;
-}
-
-void AddBandwidthPackageIpsRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
-}
-
-std::string AddBandwidthPackageIpsRequest::getIpCount()const
-{
-	return ipCount_;
-}
-
-void AddBandwidthPackageIpsRequest::setIpCount(const std::string& ipCount)
-{
-	ipCount_ = ipCount;
-	setParameter("IpCount", ipCount);
-}
-

vpc/src/model/AddCommonBandwidthPackageIpRequest.cc

@@ -38,6 +38,17 @@ void AddCommonBandwidthPackageIpRequest::setResourceOwnerId(long resourceOwnerId
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+std::string AddCommonBandwidthPackageIpRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void AddCommonBandwidthPackageIpRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
 std::string AddCommonBandwidthPackageIpRequest::getRegionId()const
 {
 	return regionId_;

vpc/src/model/AddCommonBandwidthPackageIpsRequest.cc

@@ -0,0 +1,130 @@
+/*
+ * 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/vpc/model/AddCommonBandwidthPackageIpsRequest.h>
+
+using AlibabaCloud::Vpc::Model::AddCommonBandwidthPackageIpsRequest;
+
+AddCommonBandwidthPackageIpsRequest::AddCommonBandwidthPackageIpsRequest() :
+	RpcServiceRequest("vpc", "2016-04-28", "AddCommonBandwidthPackageIps")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AddCommonBandwidthPackageIpsRequest::~AddCommonBandwidthPackageIpsRequest()
+{}
+
+long AddCommonBandwidthPackageIpsRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void AddCommonBandwidthPackageIpsRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string AddCommonBandwidthPackageIpsRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void AddCommonBandwidthPackageIpsRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::vector<std::string> AddCommonBandwidthPackageIpsRequest::getIpInstanceIds()const
+{
+	return ipInstanceIds_;
+}
+
+void AddCommonBandwidthPackageIpsRequest::setIpInstanceIds(const std::vector<std::string>& ipInstanceIds)
+{
+	ipInstanceIds_ = ipInstanceIds;
+	for(int dep1 = 0; dep1!= ipInstanceIds.size(); dep1++) {
+		setParameter("IpInstanceIds."+ std::to_string(dep1), ipInstanceIds.at(dep1));
+	}
+}
+
+std::string AddCommonBandwidthPackageIpsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void AddCommonBandwidthPackageIpsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string AddCommonBandwidthPackageIpsRequest::getBandwidthPackageId()const
+{
+	return bandwidthPackageId_;
+}
+
+void AddCommonBandwidthPackageIpsRequest::setBandwidthPackageId(const std::string& bandwidthPackageId)
+{
+	bandwidthPackageId_ = bandwidthPackageId;
+	setParameter("BandwidthPackageId", bandwidthPackageId);
+}
+
+std::string AddCommonBandwidthPackageIpsRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void AddCommonBandwidthPackageIpsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string AddCommonBandwidthPackageIpsRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void AddCommonBandwidthPackageIpsRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long AddCommonBandwidthPackageIpsRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void AddCommonBandwidthPackageIpsRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string AddCommonBandwidthPackageIpsRequest::getIpType()const
+{
+	return ipType_;
+}
+
+void AddCommonBandwidthPackageIpsRequest::setIpType(const std::string& ipType)
+{
+	ipType_ = ipType;
+	setParameter("IpType", ipType);
+}
+

vpc/src/model/AddCommonBandwidthPackageIpsResult.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/vpc/model/AddCommonBandwidthPackageIpsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+AddCommonBandwidthPackageIpsResult::AddCommonBandwidthPackageIpsResult() :
+	ServiceResult()
+{}
+
+AddCommonBandwidthPackageIpsResult::AddCommonBandwidthPackageIpsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AddCommonBandwidthPackageIpsResult::~AddCommonBandwidthPackageIpsResult()
+{}
+
+void AddCommonBandwidthPackageIpsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

vpc/src/model/AddSourcesToTrafficMirrorSessionRequest.cc

@@ -0,0 +1,130 @@
+/*
+ * 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/vpc/model/AddSourcesToTrafficMirrorSessionRequest.h>
+
+using AlibabaCloud::Vpc::Model::AddSourcesToTrafficMirrorSessionRequest;
+
+AddSourcesToTrafficMirrorSessionRequest::AddSourcesToTrafficMirrorSessionRequest() :
+	RpcServiceRequest("vpc", "2016-04-28", "AddSourcesToTrafficMirrorSession")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AddSourcesToTrafficMirrorSessionRequest::~AddSourcesToTrafficMirrorSessionRequest()
+{}
+
+long AddSourcesToTrafficMirrorSessionRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void AddSourcesToTrafficMirrorSessionRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string AddSourcesToTrafficMirrorSessionRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void AddSourcesToTrafficMirrorSessionRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string AddSourcesToTrafficMirrorSessionRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void AddSourcesToTrafficMirrorSessionRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::vector<std::string> AddSourcesToTrafficMirrorSessionRequest::getTrafficMirrorSourceIds()const
+{
+	return trafficMirrorSourceIds_;
+}
+
+void AddSourcesToTrafficMirrorSessionRequest::setTrafficMirrorSourceIds(const std::vector<std::string>& trafficMirrorSourceIds)
+{
+	trafficMirrorSourceIds_ = trafficMirrorSourceIds;
+	for(int dep1 = 0; dep1!= trafficMirrorSourceIds.size(); dep1++) {
+		setParameter("TrafficMirrorSourceIds."+ std::to_string(dep1), trafficMirrorSourceIds.at(dep1));
+	}
+}
+
+bool AddSourcesToTrafficMirrorSessionRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void AddSourcesToTrafficMirrorSessionRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string AddSourcesToTrafficMirrorSessionRequest::getTrafficMirrorSessionId()const
+{
+	return trafficMirrorSessionId_;
+}
+
+void AddSourcesToTrafficMirrorSessionRequest::setTrafficMirrorSessionId(const std::string& trafficMirrorSessionId)
+{
+	trafficMirrorSessionId_ = trafficMirrorSessionId;
+	setParameter("TrafficMirrorSessionId", trafficMirrorSessionId);
+}
+
+std::string AddSourcesToTrafficMirrorSessionRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void AddSourcesToTrafficMirrorSessionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string AddSourcesToTrafficMirrorSessionRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void AddSourcesToTrafficMirrorSessionRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long AddSourcesToTrafficMirrorSessionRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void AddSourcesToTrafficMirrorSessionRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

vpc/src/model/AddSourcesToTrafficMirrorSessionResult.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/vpc/model/AddSourcesToTrafficMirrorSessionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+AddSourcesToTrafficMirrorSessionResult::AddSourcesToTrafficMirrorSessionResult() :
+	ServiceResult()
+{}
+
+AddSourcesToTrafficMirrorSessionResult::AddSourcesToTrafficMirrorSessionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AddSourcesToTrafficMirrorSessionResult::~AddSourcesToTrafficMirrorSessionResult()
+{}
+
+void AddSourcesToTrafficMirrorSessionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

vpc/src/model/AllocateEipAddressProRequest.cc

@@ -0,0 +1,216 @@
+/*
+ * 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/vpc/model/AllocateEipAddressProRequest.h>
+
+using AlibabaCloud::Vpc::Model::AllocateEipAddressProRequest;
+
+AllocateEipAddressProRequest::AllocateEipAddressProRequest() :
+	RpcServiceRequest("vpc", "2016-04-28", "AllocateEipAddressPro")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AllocateEipAddressProRequest::~AllocateEipAddressProRequest()
+{}
+
+std::string AllocateEipAddressProRequest::getIpAddress()const
+{
+	return ipAddress_;
+}
+
+void AllocateEipAddressProRequest::setIpAddress(const std::string& ipAddress)
+{
+	ipAddress_ = ipAddress;
+	setParameter("IpAddress", ipAddress);
+}
+
+long AllocateEipAddressProRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void AllocateEipAddressProRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string AllocateEipAddressProRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void AllocateEipAddressProRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string AllocateEipAddressProRequest::getISP()const
+{
+	return iSP_;
+}
+
+void AllocateEipAddressProRequest::setISP(const std::string& iSP)
+{
+	iSP_ = iSP;
+	setParameter("ISP", iSP);
+}
+
+std::string AllocateEipAddressProRequest::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+void AllocateEipAddressProRequest::setResourceGroupId(const std::string& resourceGroupId)
+{
+	resourceGroupId_ = resourceGroupId;
+	setParameter("ResourceGroupId", resourceGroupId);
+}
+
+std::string AllocateEipAddressProRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void AllocateEipAddressProRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string AllocateEipAddressProRequest::getNetmode()const
+{
+	return netmode_;
+}
+
+void AllocateEipAddressProRequest::setNetmode(const std::string& netmode)
+{
+	netmode_ = netmode;
+	setParameter("Netmode", netmode);
+}
+
+std::string AllocateEipAddressProRequest::getInstanceChargeType()const
+{
+	return instanceChargeType_;
+}
+
+void AllocateEipAddressProRequest::setInstanceChargeType(const std::string& instanceChargeType)
+{
+	instanceChargeType_ = instanceChargeType;
+	setParameter("InstanceChargeType", instanceChargeType);
+}
+
+int AllocateEipAddressProRequest::getPeriod()const
+{
+	return period_;
+}
+
+void AllocateEipAddressProRequest::setPeriod(int period)
+{
+	period_ = period;
+	setParameter("Period", std::to_string(period));
+}
+
+bool AllocateEipAddressProRequest::getAutoPay()const
+{
+	return autoPay_;
+}
+
+void AllocateEipAddressProRequest::setAutoPay(bool autoPay)
+{
+	autoPay_ = autoPay;
+	setParameter("AutoPay", autoPay ? "true" : "false");
+}
+
+std::string AllocateEipAddressProRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void AllocateEipAddressProRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string AllocateEipAddressProRequest::getBandwidth()const
+{
+	return bandwidth_;
+}
+
+void AllocateEipAddressProRequest::setBandwidth(const std::string& bandwidth)
+{
+	bandwidth_ = bandwidth;
+	setParameter("Bandwidth", bandwidth);
+}
+
+std::string AllocateEipAddressProRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void AllocateEipAddressProRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long AllocateEipAddressProRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void AllocateEipAddressProRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string AllocateEipAddressProRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void AllocateEipAddressProRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string AllocateEipAddressProRequest::getInternetChargeType()const
+{
+	return internetChargeType_;
+}
+
+void AllocateEipAddressProRequest::setInternetChargeType(const std::string& internetChargeType)
+{
+	internetChargeType_ = internetChargeType;
+	setParameter("InternetChargeType", internetChargeType);
+}
+
+std::string AllocateEipAddressProRequest::getPricingCycle()const
+{
+	return pricingCycle_;
+}
+
+void AllocateEipAddressProRequest::setPricingCycle(const std::string& pricingCycle)
+{
+	pricingCycle_ = pricingCycle;
+	setParameter("PricingCycle", pricingCycle);
+}
+

vpc/src/model/AllocateEipAddressProResult.cc

@@ -0,0 +1,72 @@
+/*
+ * 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/vpc/model/AllocateEipAddressProResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+AllocateEipAddressProResult::AllocateEipAddressProResult() :
+	ServiceResult()
+{}
+
+AllocateEipAddressProResult::AllocateEipAddressProResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AllocateEipAddressProResult::~AllocateEipAddressProResult()
+{}
+
+void AllocateEipAddressProResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["AllocationId"].isNull())
+		allocationId_ = value["AllocationId"].asString();
+	if(!value["EipAddress"].isNull())
+		eipAddress_ = value["EipAddress"].asString();
+	if(!value["OrderId"].isNull())
+		orderId_ = std::stol(value["OrderId"].asString());
+	if(!value["ResourceGroupId"].isNull())
+		resourceGroupId_ = value["ResourceGroupId"].asString();
+
+}
+
+std::string AllocateEipAddressProResult::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+std::string AllocateEipAddressProResult::getAllocationId()const
+{
+	return allocationId_;
+}
+
+std::string AllocateEipAddressProResult::getEipAddress()const
+{
+	return eipAddress_;
+}
+
+long AllocateEipAddressProResult::getOrderId()const
+{
+	return orderId_;
+}
+

vpc/src/model/AllocateEipAddressRequest.cc

@@ -60,6 +60,17 @@ void AllocateEipAddressRequest::setISP(const std::string& iSP)
 	setParameter("ISP", iSP);
 }
 
+std::string AllocateEipAddressRequest::getDescription()const
+{
+	return description_;
+}
+
+void AllocateEipAddressRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
 std::string AllocateEipAddressRequest::getResourceGroupId()const
 {
 	return resourceGroupId_;
@@ -192,6 +203,17 @@ void AllocateEipAddressRequest::setInternetChargeType(const std::string& interne
 	setParameter("InternetChargeType", internetChargeType);
 }
 
+std::string AllocateEipAddressRequest::getName()const
+{
+	return name_;
+}
+
+void AllocateEipAddressRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
 std::string AllocateEipAddressRequest::getPricingCycle()const
 {
 	return pricingCycle_;

vpc/src/model/AllocateEipSegmentAddressRequest.cc

@@ -49,6 +49,17 @@ void AllocateEipSegmentAddressRequest::setClientToken(const std::string& clientT
 	setParameter("ClientToken", clientToken);
 }
 
+std::string AllocateEipSegmentAddressRequest::getIsp()const
+{
+	return isp_;
+}
+
+void AllocateEipSegmentAddressRequest::setIsp(const std::string& isp)
+{
+	isp_ = isp;
+	setParameter("Isp", isp);
+}
+
 std::string AllocateEipSegmentAddressRequest::getResourceGroupId()const
 {
 	return resourceGroupId_;

vpc/src/model/AssociateHaVipRequest.cc

@@ -60,6 +60,17 @@ void AssociateHaVipRequest::setRegionId(const std::string& regionId)
 	setParameter("RegionId", regionId);
 }
 
+std::string AssociateHaVipRequest::getInstanceType()const
+{
+	return instanceType_;
+}
+
+void AssociateHaVipRequest::setInstanceType(const std::string& instanceType)
+{
+	instanceType_ = instanceType;
+	setParameter("InstanceType", instanceType);
+}
+
 std::string AssociateHaVipRequest::getHaVipId()const
 {
 	return haVipId_;

vpc/src/model/AssociatePhysicalConnectionToVirtualBorderRouterRequest.cc

@@ -71,6 +71,17 @@ void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setClientToken(con
 	setParameter("ClientToken", clientToken);
 }
 
+std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getEnableIpv6()const
+{
+	return enableIpv6_;
+}
+
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setEnableIpv6(const std::string& enableIpv6)
+{
+	enableIpv6_ = enableIpv6;
+	setParameter("EnableIpv6", enableIpv6);
+}
+
 std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getVbrId()const
 {
 	return vbrId_;
@@ -93,6 +104,17 @@ void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setPeerGatewayIp(c
 	setParameter("PeerGatewayIp", peerGatewayIp);
 }
 
+std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getPeerIpv6GatewayIp()const
+{
+	return peerIpv6GatewayIp_;
+}
+
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setPeerIpv6GatewayIp(const std::string& peerIpv6GatewayIp)
+{
+	peerIpv6GatewayIp_ = peerIpv6GatewayIp;
+	setParameter("PeerIpv6GatewayIp", peerIpv6GatewayIp);
+}
+
 std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getPeeringSubnetMask()const
 {
 	return peeringSubnetMask_;
@@ -126,6 +148,17 @@ void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setLocalGatewayIp(
 	setParameter("LocalGatewayIp", localGatewayIp);
 }
 
+std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getPeeringIpv6SubnetMask()const
+{
+	return peeringIpv6SubnetMask_;
+}
+
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setPeeringIpv6SubnetMask(const std::string& peeringIpv6SubnetMask)
+{
+	peeringIpv6SubnetMask_ = peeringIpv6SubnetMask;
+	setParameter("PeeringIpv6SubnetMask", peeringIpv6SubnetMask);
+}
+
 std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -170,3 +203,14 @@ void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setPhysicalConnect
 	setParameter("PhysicalConnectionId", physicalConnectionId);
 }
 
+std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getLocalIpv6GatewayIp()const
+{
+	return localIpv6GatewayIp_;
+}
+
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setLocalIpv6GatewayIp(const std::string& localIpv6GatewayIp)
+{
+	localIpv6GatewayIp_ = localIpv6GatewayIp;
+	setParameter("LocalIpv6GatewayIp", localIpv6GatewayIp);
+}
+

vpc/src/model/AssociateVpcCidrBlockRequest.cc

@@ -60,6 +60,28 @@ void AssociateVpcCidrBlockRequest::setRegionId(const std::string& regionId)
 	setParameter("RegionId", regionId);
 }
 
+std::string AssociateVpcCidrBlockRequest::getIpv6Isp()const
+{
+	return ipv6Isp_;
+}
+
+void AssociateVpcCidrBlockRequest::setIpv6Isp(const std::string& ipv6Isp)
+{
+	ipv6Isp_ = ipv6Isp;
+	setParameter("Ipv6Isp", ipv6Isp);
+}
+
+std::string AssociateVpcCidrBlockRequest::getIpVersion()const
+{
+	return ipVersion_;
+}
+
+void AssociateVpcCidrBlockRequest::setIpVersion(const std::string& ipVersion)
+{
+	ipVersion_ = ipVersion;
+	setParameter("IpVersion", ipVersion);
+}
+
 std::string AssociateVpcCidrBlockRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;

vpc/src/model/AssociateVpnGatewayWithCertificateRequest.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/vpc/model/AssociateVpnGatewayWithCertificateRequest.h>
+
+using AlibabaCloud::Vpc::Model::AssociateVpnGatewayWithCertificateRequest;
+
+AssociateVpnGatewayWithCertificateRequest::AssociateVpnGatewayWithCertificateRequest() :
+	RpcServiceRequest("vpc", "2016-04-28", "AssociateVpnGatewayWithCertificate")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AssociateVpnGatewayWithCertificateRequest::~AssociateVpnGatewayWithCertificateRequest()
+{}
+
+long AssociateVpnGatewayWithCertificateRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void AssociateVpnGatewayWithCertificateRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+bool AssociateVpnGatewayWithCertificateRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void AssociateVpnGatewayWithCertificateRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string AssociateVpnGatewayWithCertificateRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void AssociateVpnGatewayWithCertificateRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string AssociateVpnGatewayWithCertificateRequest::getCertificateId()const
+{
+	return certificateId_;
+}
+
+void AssociateVpnGatewayWithCertificateRequest::setCertificateId(const std::string& certificateId)
+{
+	certificateId_ = certificateId;
+	setParameter("CertificateId", certificateId);
+}
+
+std::string AssociateVpnGatewayWithCertificateRequest::getVpnGatewayId()const
+{
+	return vpnGatewayId_;
+}
+
+void AssociateVpnGatewayWithCertificateRequest::setVpnGatewayId(const std::string& vpnGatewayId)
+{
+	vpnGatewayId_ = vpnGatewayId;
+	setParameter("VpnGatewayId", vpnGatewayId);
+}
+
+std::string AssociateVpnGatewayWithCertificateRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void AssociateVpnGatewayWithCertificateRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+std::string AssociateVpnGatewayWithCertificateRequest::getCertificateType()const
+{
+	return certificateType_;
+}
+
+void AssociateVpnGatewayWithCertificateRequest::setCertificateType(const std::string& certificateType)
+{
+	certificateType_ = certificateType;
+	setParameter("CertificateType", certificateType);
+}
+
+std::string AssociateVpnGatewayWithCertificateRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void AssociateVpnGatewayWithCertificateRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+

vpc/src/model/AssociateVpnGatewayWithCertificateResult.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/vpc/model/AssociateVpnGatewayWithCertificateResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+AssociateVpnGatewayWithCertificateResult::AssociateVpnGatewayWithCertificateResult() :
+	ServiceResult()
+{}
+
+AssociateVpnGatewayWithCertificateResult::AssociateVpnGatewayWithCertificateResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AssociateVpnGatewayWithCertificateResult::~AssociateVpnGatewayWithCertificateResult()
+{}
+
+void AssociateVpnGatewayWithCertificateResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

vpc/src/model/AttachDhcpOptionsSetToVpcRequest.cc

@@ -0,0 +1,128 @@
+/*
+ * 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/vpc/model/AttachDhcpOptionsSetToVpcRequest.h>
+
+using AlibabaCloud::Vpc::Model::AttachDhcpOptionsSetToVpcRequest;
+
+AttachDhcpOptionsSetToVpcRequest::AttachDhcpOptionsSetToVpcRequest() :
+	RpcServiceRequest("vpc", "2016-04-28", "AttachDhcpOptionsSetToVpc")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AttachDhcpOptionsSetToVpcRequest::~AttachDhcpOptionsSetToVpcRequest()
+{}
+
+long AttachDhcpOptionsSetToVpcRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void AttachDhcpOptionsSetToVpcRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string AttachDhcpOptionsSetToVpcRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void AttachDhcpOptionsSetToVpcRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string AttachDhcpOptionsSetToVpcRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void AttachDhcpOptionsSetToVpcRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+bool AttachDhcpOptionsSetToVpcRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void AttachDhcpOptionsSetToVpcRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string AttachDhcpOptionsSetToVpcRequest::getDhcpOptionsSetId()const
+{
+	return dhcpOptionsSetId_;
+}
+
+void AttachDhcpOptionsSetToVpcRequest::setDhcpOptionsSetId(const std::string& dhcpOptionsSetId)
+{
+	dhcpOptionsSetId_ = dhcpOptionsSetId;
+	setParameter("DhcpOptionsSetId", dhcpOptionsSetId);
+}
+
+std::string AttachDhcpOptionsSetToVpcRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void AttachDhcpOptionsSetToVpcRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string AttachDhcpOptionsSetToVpcRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void AttachDhcpOptionsSetToVpcRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long AttachDhcpOptionsSetToVpcRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void AttachDhcpOptionsSetToVpcRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string AttachDhcpOptionsSetToVpcRequest::getVpcId()const
+{
+	return vpcId_;
+}
+
+void AttachDhcpOptionsSetToVpcRequest::setVpcId(const std::string& vpcId)
+{
+	vpcId_ = vpcId;
+	setParameter("VpcId", vpcId);
+}
+

vpc/src/model/AttachDhcpOptionsSetToVpcResult.cc

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

vpc/src/model/ConfirmPhysicalConnectionRequest.cc

@@ -0,0 +1,106 @@
+/*
+ * 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/vpc/model/ConfirmPhysicalConnectionRequest.h>
+
+using AlibabaCloud::Vpc::Model::ConfirmPhysicalConnectionRequest;
+
+ConfirmPhysicalConnectionRequest::ConfirmPhysicalConnectionRequest() :
+	RpcServiceRequest("vpc", "2016-04-28", "ConfirmPhysicalConnection")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ConfirmPhysicalConnectionRequest::~ConfirmPhysicalConnectionRequest()
+{}
+
+long ConfirmPhysicalConnectionRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void ConfirmPhysicalConnectionRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string ConfirmPhysicalConnectionRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void ConfirmPhysicalConnectionRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string ConfirmPhysicalConnectionRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ConfirmPhysicalConnectionRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string ConfirmPhysicalConnectionRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void ConfirmPhysicalConnectionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string ConfirmPhysicalConnectionRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void ConfirmPhysicalConnectionRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long ConfirmPhysicalConnectionRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ConfirmPhysicalConnectionRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string ConfirmPhysicalConnectionRequest::getPhysicalConnectionId()const
+{
+	return physicalConnectionId_;
+}
+
+void ConfirmPhysicalConnectionRequest::setPhysicalConnectionId(const std::string& physicalConnectionId)
+{
+	physicalConnectionId_ = physicalConnectionId;
+	setParameter("PhysicalConnectionId", physicalConnectionId);
+}
+

vpc/src/model/ConfirmPhysicalConnectionResult.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/vpc/model/ConfirmPhysicalConnectionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+ConfirmPhysicalConnectionResult::ConfirmPhysicalConnectionResult() :
+	ServiceResult()
+{}
+
+ConfirmPhysicalConnectionResult::ConfirmPhysicalConnectionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ConfirmPhysicalConnectionResult::~ConfirmPhysicalConnectionResult()
+{}
+
+void ConfirmPhysicalConnectionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

vpc/src/model/CreateBandwidthPackageRequest.cc

@@ -1,183 +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/vpc/model/CreateBandwidthPackageRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateBandwidthPackageRequest;
-
-CreateBandwidthPackageRequest::CreateBandwidthPackageRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateBandwidthPackage")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateBandwidthPackageRequest::~CreateBandwidthPackageRequest()
-{}
-
-long CreateBandwidthPackageRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
-}
-
-void CreateBandwidthPackageRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
-}
-
-std::string CreateBandwidthPackageRequest::getClientToken()const
-{
-	return clientToken_;
-}
-
-void CreateBandwidthPackageRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
-}
-
-std::string CreateBandwidthPackageRequest::getISP()const
-{
-	return iSP_;
-}
-
-void CreateBandwidthPackageRequest::setISP(const std::string& iSP)
-{
-	iSP_ = iSP;
-	setParameter("ISP", iSP);
-}
-
-std::string CreateBandwidthPackageRequest::getDescription()const
-{
-	return description_;
-}
-
-void CreateBandwidthPackageRequest::setDescription(const std::string& description)
-{
-	description_ = description;
-	setParameter("Description", description);
-}
-
-std::string CreateBandwidthPackageRequest::getRegionId()const
-{
-	return regionId_;
-}
-
-void CreateBandwidthPackageRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
-}
-
-std::string CreateBandwidthPackageRequest::getZone()const
-{
-	return zone_;
-}
-
-void CreateBandwidthPackageRequest::setZone(const std::string& zone)
-{
-	zone_ = zone;
-	setParameter("Zone", zone);
-}
-
-std::string CreateBandwidthPackageRequest::getNatGatewayId()const
-{
-	return natGatewayId_;
-}
-
-void CreateBandwidthPackageRequest::setNatGatewayId(const std::string& natGatewayId)
-{
-	natGatewayId_ = natGatewayId;
-	setParameter("NatGatewayId", natGatewayId);
-}
-
-std::string CreateBandwidthPackageRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
-}
-
-void CreateBandwidthPackageRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
-}
-
-int CreateBandwidthPackageRequest::getBandwidth()const
-{
-	return bandwidth_;
-}
-
-void CreateBandwidthPackageRequest::setBandwidth(int bandwidth)
-{
-	bandwidth_ = bandwidth;
-	setParameter("Bandwidth", std::to_string(bandwidth));
-}
-
-std::string CreateBandwidthPackageRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
-}
-
-void CreateBandwidthPackageRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
-}
-
-long CreateBandwidthPackageRequest::getOwnerId()const
-{
-	return ownerId_;
-}
-
-void CreateBandwidthPackageRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
-}
-
-std::string CreateBandwidthPackageRequest::getInternetChargeType()const
-{
-	return internetChargeType_;
-}
-
-void CreateBandwidthPackageRequest::setInternetChargeType(const std::string& internetChargeType)
-{
-	internetChargeType_ = internetChargeType;
-	setParameter("InternetChargeType", internetChargeType);
-}
-
-std::string CreateBandwidthPackageRequest::getName()const
-{
-	return name_;
-}
-
-void CreateBandwidthPackageRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
-}
-
-int CreateBandwidthPackageRequest::getIpCount()const
-{
-	return ipCount_;
-}
-
-void CreateBandwidthPackageRequest::setIpCount(int ipCount)
-{
-	ipCount_ = ipCount;
-	setParameter("IpCount", std::to_string(ipCount));
-}
-

vpc/src/model/CreateBgpGroupRequest.cc

@@ -104,6 +104,17 @@ void CreateBgpGroupRequest::setRegionId(const std::string& regionId)
 	setParameter("RegionId", regionId);
 }
 
+std::string CreateBgpGroupRequest::getIpVersion()const
+{
+	return ipVersion_;
+}
+
+void CreateBgpGroupRequest::setIpVersion(const std::string& ipVersion)
+{
+	ipVersion_ = ipVersion;
+	setParameter("IpVersion", ipVersion);
+}
+
 std::string CreateBgpGroupRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;

vpc/src/model/CreateBgpPeerRequest.cc

@@ -71,6 +71,17 @@ void CreateBgpPeerRequest::setPeerIpAddress(const std::string& peerIpAddress)
 	setParameter("PeerIpAddress", peerIpAddress);
 }
 
+int CreateBgpPeerRequest::getBfdMultiHop()const
+{
+	return bfdMultiHop_;
+}
+
+void CreateBgpPeerRequest::setBfdMultiHop(int bfdMultiHop)
+{
+	bfdMultiHop_ = bfdMultiHop;
+	setParameter("BfdMultiHop", std::to_string(bfdMultiHop));
+}
+
 std::string CreateBgpPeerRequest::getRegionId()const
 {
 	return regionId_;
@@ -82,6 +93,17 @@ void CreateBgpPeerRequest::setRegionId(const std::string& regionId)
 	setParameter("RegionId", regionId);
 }
 
+std::string CreateBgpPeerRequest::getIpVersion()const
+{
+	return ipVersion_;
+}
+
+void CreateBgpPeerRequest::setIpVersion(const std::string& ipVersion)
+{
+	ipVersion_ = ipVersion;
+	setParameter("IpVersion", ipVersion);
+}
+
 bool CreateBgpPeerRequest::getEnableBfd()const
 {
 	return enableBfd_;

vpc/src/model/CreateCustomerGatewayRequest.cc

@@ -126,3 +126,14 @@ void CreateCustomerGatewayRequest::setName(const std::string& name)
 	setParameter("Name", name);
 }
 
+std::string CreateCustomerGatewayRequest::getAsn()const
+{
+	return asn_;
+}
+
+void CreateCustomerGatewayRequest::setAsn(const std::string& asn)
+{
+	asn_ = asn;
+	setParameter("Asn", asn);
+}
+

vpc/src/model/CreateDhcpOptionsSetRequest.cc

@@ -0,0 +1,172 @@
+/*
+ * 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/vpc/model/CreateDhcpOptionsSetRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateDhcpOptionsSetRequest;
+
+CreateDhcpOptionsSetRequest::CreateDhcpOptionsSetRequest() :
+	RpcServiceRequest("vpc", "2016-04-28", "CreateDhcpOptionsSet")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateDhcpOptionsSetRequest::~CreateDhcpOptionsSetRequest()
+{}
+
+std::string CreateDhcpOptionsSetRequest::getBootFileName()const
+{
+	return bootFileName_;
+}
+
+void CreateDhcpOptionsSetRequest::setBootFileName(const std::string& bootFileName)
+{
+	bootFileName_ = bootFileName;
+	setParameter("BootFileName", bootFileName);
+}
+
+long CreateDhcpOptionsSetRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateDhcpOptionsSetRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string CreateDhcpOptionsSetRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateDhcpOptionsSetRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string CreateDhcpOptionsSetRequest::getTFTPServerName()const
+{
+	return tFTPServerName_;
+}
+
+void CreateDhcpOptionsSetRequest::setTFTPServerName(const std::string& tFTPServerName)
+{
+	tFTPServerName_ = tFTPServerName;
+	setParameter("TFTPServerName", tFTPServerName);
+}
+
+std::string CreateDhcpOptionsSetRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateDhcpOptionsSetRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreateDhcpOptionsSetRequest::getDomainNameServers()const
+{
+	return domainNameServers_;
+}
+
+void CreateDhcpOptionsSetRequest::setDomainNameServers(const std::string& domainNameServers)
+{
+	domainNameServers_ = domainNameServers;
+	setParameter("DomainNameServers", domainNameServers);
+}
+
+std::string CreateDhcpOptionsSetRequest::getDhcpOptionsSetDescription()const
+{
+	return dhcpOptionsSetDescription_;
+}
+
+void CreateDhcpOptionsSetRequest::setDhcpOptionsSetDescription(const std::string& dhcpOptionsSetDescription)
+{
+	dhcpOptionsSetDescription_ = dhcpOptionsSetDescription;
+	setParameter("DhcpOptionsSetDescription", dhcpOptionsSetDescription);
+}
+
+bool CreateDhcpOptionsSetRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void CreateDhcpOptionsSetRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string CreateDhcpOptionsSetRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateDhcpOptionsSetRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateDhcpOptionsSetRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateDhcpOptionsSetRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string CreateDhcpOptionsSetRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void CreateDhcpOptionsSetRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long CreateDhcpOptionsSetRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateDhcpOptionsSetRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateDhcpOptionsSetRequest::getDhcpOptionsSetName()const
+{
+	return dhcpOptionsSetName_;
+}
+
+void CreateDhcpOptionsSetRequest::setDhcpOptionsSetName(const std::string& dhcpOptionsSetName)
+{
+	dhcpOptionsSetName_ = dhcpOptionsSetName;
+	setParameter("DhcpOptionsSetName", dhcpOptionsSetName);
+}
+

vpc/src/model/CreateDhcpOptionsSetResult.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/vpc/model/CreateDhcpOptionsSetResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+CreateDhcpOptionsSetResult::CreateDhcpOptionsSetResult() :
+	ServiceResult()
+{}
+
+CreateDhcpOptionsSetResult::CreateDhcpOptionsSetResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateDhcpOptionsSetResult::~CreateDhcpOptionsSetResult()
+{}
+
+void CreateDhcpOptionsSetResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["DhcpOptionsSetId"].isNull())
+		dhcpOptionsSetId_ = value["DhcpOptionsSetId"].asString();
+
+}
+
+std::string CreateDhcpOptionsSetResult::getDhcpOptionsSetId()const
+{
+	return dhcpOptionsSetId_;
+}
+

vpc/src/model/CreateForwardEntryRequest.cc

@@ -159,6 +159,17 @@ void CreateForwardEntryRequest::setInternalPort(const std::string& internalPort)
 	setParameter("InternalPort", internalPort);
 }
 
+bool CreateForwardEntryRequest::getPortBreak()const
+{
+	return portBreak_;
+}
+
+void CreateForwardEntryRequest::setPortBreak(bool portBreak)
+{
+	portBreak_ = portBreak;
+	setParameter("PortBreak", portBreak ? "true" : "false");
+}
+
 std::string CreateForwardEntryRequest::getExternalPort()const
 {
 	return externalPort_;

vpc/src/model/CreateIpsecServerRequest.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/vpc/model/CreateIpsecServerRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateIpsecServerRequest;
+
+CreateIpsecServerRequest::CreateIpsecServerRequest() :
+	RpcServiceRequest("vpc", "2016-04-28", "CreateIpsecServer")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateIpsecServerRequest::~CreateIpsecServerRequest()
+{}
+
+std::string CreateIpsecServerRequest::getIkeConfig()const
+{
+	return ikeConfig_;
+}
+
+void CreateIpsecServerRequest::setIkeConfig(const std::string& ikeConfig)
+{
+	ikeConfig_ = ikeConfig;
+	setParameter("IkeConfig", ikeConfig);
+}
+
+long CreateIpsecServerRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateIpsecServerRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string CreateIpsecServerRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateIpsecServerRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string CreateIpsecServerRequest::getIpsecConfig()const
+{
+	return ipsecConfig_;
+}
+
+void CreateIpsecServerRequest::setIpsecConfig(const std::string& ipsecConfig)
+{
+	ipsecConfig_ = ipsecConfig;
+	setParameter("IpsecConfig", ipsecConfig);
+}
+
+std::string CreateIpsecServerRequest::getPsk()const
+{
+	return psk_;
+}
+
+void CreateIpsecServerRequest::setPsk(const std::string& psk)
+{
+	psk_ = psk;
+	setParameter("Psk", psk);
+}
+
+std::string CreateIpsecServerRequest::getLocalSubnet()const
+{
+	return localSubnet_;
+}
+
+void CreateIpsecServerRequest::setLocalSubnet(const std::string& localSubnet)
+{
+	localSubnet_ = localSubnet;
+	setParameter("LocalSubnet", localSubnet);
+}
+
+std::string CreateIpsecServerRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateIpsecServerRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreateIpsecServerRequest::getIDaaSInstanceId()const
+{
+	return iDaaSInstanceId_;
+}
+
+void CreateIpsecServerRequest::setIDaaSInstanceId(const std::string& iDaaSInstanceId)
+{
+	iDaaSInstanceId_ = iDaaSInstanceId;
+	setParameter("IDaaSInstanceId", iDaaSInstanceId);
+}
+
+bool CreateIpsecServerRequest::getEffectImmediately()const
+{
+	return effectImmediately_;
+}
+
+void CreateIpsecServerRequest::setEffectImmediately(bool effectImmediately)
+{
+	effectImmediately_ = effectImmediately;
+	setParameter("EffectImmediately", effectImmediately ? "true" : "false");
+}
+
+std::string CreateIpsecServerRequest::getClientIpPool()const
+{
+	return clientIpPool_;
+}
+
+void CreateIpsecServerRequest::setClientIpPool(const std::string& clientIpPool)
+{
+	clientIpPool_ = clientIpPool;
+	setParameter("ClientIpPool", clientIpPool);
+}
+
+std::string CreateIpsecServerRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void CreateIpsecServerRequest::setDryRun(const std::string& dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun);
+}
+
+std::string CreateIpsecServerRequest::getVpnGatewayId()const
+{
+	return vpnGatewayId_;
+}
+
+void CreateIpsecServerRequest::setVpnGatewayId(const std::string& vpnGatewayId)
+{
+	vpnGatewayId_ = vpnGatewayId;
+	setParameter("VpnGatewayId", vpnGatewayId);
+}
+
+std::string CreateIpsecServerRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void CreateIpsecServerRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+bool CreateIpsecServerRequest::getPskEnabled()const
+{
+	return pskEnabled_;
+}
+
+void CreateIpsecServerRequest::setPskEnabled(bool pskEnabled)
+{
+	pskEnabled_ = pskEnabled;
+	setParameter("PskEnabled", pskEnabled ? "true" : "false");
+}
+
+bool CreateIpsecServerRequest::getMultiFactorAuthEnabled()const
+{
+	return multiFactorAuthEnabled_;
+}
+
+void CreateIpsecServerRequest::setMultiFactorAuthEnabled(bool multiFactorAuthEnabled)
+{
+	multiFactorAuthEnabled_ = multiFactorAuthEnabled;
+	setParameter("MultiFactorAuthEnabled", multiFactorAuthEnabled ? "true" : "false");
+}
+
+std::string CreateIpsecServerRequest::getIpSecServerName()const
+{
+	return ipSecServerName_;
+}
+
+void CreateIpsecServerRequest::setIpSecServerName(const std::string& ipSecServerName)
+{
+	ipSecServerName_ = ipSecServerName;
+	setParameter("IpSecServerName", ipSecServerName);
+}
+

vpc/src/model/CreateIpsecServerResult.cc

@@ -0,0 +1,79 @@
+/*
+ * 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/vpc/model/CreateIpsecServerResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+CreateIpsecServerResult::CreateIpsecServerResult() :
+	ServiceResult()
+{}
+
+CreateIpsecServerResult::CreateIpsecServerResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateIpsecServerResult::~CreateIpsecServerResult()
+{}
+
+void CreateIpsecServerResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["RegionId"].isNull())
+		regionId_ = value["RegionId"].asString();
+	if(!value["IpsecServerId"].isNull())
+		ipsecServerId_ = value["IpsecServerId"].asString();
+	if(!value["IpsecServerName"].isNull())
+		ipsecServerName_ = value["IpsecServerName"].asString();
+	if(!value["VpnGatewayId"].isNull())
+		vpnGatewayId_ = value["VpnGatewayId"].asString();
+	if(!value["CreationTime"].isNull())
+		creationTime_ = value["CreationTime"].asString();
+
+}
+
+std::string CreateIpsecServerResult::getVpnGatewayId()const
+{
+	return vpnGatewayId_;
+}
+
+std::string CreateIpsecServerResult::getIpsecServerId()const
+{
+	return ipsecServerId_;
+}
+
+std::string CreateIpsecServerResult::getCreationTime()const
+{
+	return creationTime_;
+}
+
+std::string CreateIpsecServerResult::getRegionId()const
+{
+	return regionId_;
+}
+
+std::string CreateIpsecServerResult::getIpsecServerName()const
+{
+	return ipsecServerName_;
+}
+

vpc/src/model/CreateRouteEntryResult.cc

@@ -39,6 +39,13 @@ void CreateRouteEntryResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	if(!value["RouteEntryId"].isNull())
+		routeEntryId_ = value["RouteEntryId"].asString();
 
 }
 
+std::string CreateRouteEntryResult::getRouteEntryId()const
+{
+	return routeEntryId_;
+}
+

vpc/src/model/CreateSslVpnServerRequest.cc

@@ -60,6 +60,17 @@ void CreateSslVpnServerRequest::setLocalSubnet(const std::string& localSubnet)
 	setParameter("LocalSubnet", localSubnet);
 }
 
+std::string CreateSslVpnServerRequest::getIDaaSRegionId()const
+{
+	return iDaaSRegionId_;
+}
+
+void CreateSslVpnServerRequest::setIDaaSRegionId(const std::string& iDaaSRegionId)
+{
+	iDaaSRegionId_ = iDaaSRegionId;
+	setParameter("IDaaSRegionId", iDaaSRegionId);
+}
+
 std::string CreateSslVpnServerRequest::getRegionId()const
 {
 	return regionId_;

vpc/src/model/CreateTrafficMirrorFilterRequest.cc

@@ -0,0 +1,170 @@
+/*
+ * 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/vpc/model/CreateTrafficMirrorFilterRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateTrafficMirrorFilterRequest;
+
+CreateTrafficMirrorFilterRequest::CreateTrafficMirrorFilterRequest() :
+	RpcServiceRequest("vpc", "2016-04-28", "CreateTrafficMirrorFilter")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateTrafficMirrorFilterRequest::~CreateTrafficMirrorFilterRequest()
+{}
+
+long CreateTrafficMirrorFilterRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateTrafficMirrorFilterRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string CreateTrafficMirrorFilterRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateTrafficMirrorFilterRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::vector<CreateTrafficMirrorFilterRequest::IngressRules> CreateTrafficMirrorFilterRequest::getIngressRules()const
+{
+	return ingressRules_;
+}
+
+void CreateTrafficMirrorFilterRequest::setIngressRules(const std::vector<IngressRules>& ingressRules)
+{
+	ingressRules_ = ingressRules;
+	for(int dep1 = 0; dep1!= ingressRules.size(); dep1++) {
+		auto ingressRulesObj = ingressRules.at(dep1);
+		std::string ingressRulesObjStr = "IngressRules." + std::to_string(dep1 + 1);
+		setParameter(ingressRulesObjStr + ".Priority", std::to_string(ingressRulesObj.priority));
+		setParameter(ingressRulesObjStr + ".Action", ingressRulesObj.action);
+		setParameter(ingressRulesObjStr + ".Protocol", ingressRulesObj.protocol);
+		setParameter(ingressRulesObjStr + ".DestinationCidrBlock", ingressRulesObj.destinationCidrBlock);
+		setParameter(ingressRulesObjStr + ".SourceCidrBlock", ingressRulesObj.sourceCidrBlock);
+		setParameter(ingressRulesObjStr + ".DestinationPortRange", ingressRulesObj.destinationPortRange);
+		setParameter(ingressRulesObjStr + ".SourcePortRange", ingressRulesObj.sourcePortRange);
+	}
+}
+
+std::string CreateTrafficMirrorFilterRequest::getTrafficMirrorFilterName()const
+{
+	return trafficMirrorFilterName_;
+}
+
+void CreateTrafficMirrorFilterRequest::setTrafficMirrorFilterName(const std::string& trafficMirrorFilterName)
+{
+	trafficMirrorFilterName_ = trafficMirrorFilterName;
+	setParameter("TrafficMirrorFilterName", trafficMirrorFilterName);
+}
+
+std::string CreateTrafficMirrorFilterRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateTrafficMirrorFilterRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::vector<CreateTrafficMirrorFilterRequest::EgressRules> CreateTrafficMirrorFilterRequest::getEgressRules()const
+{
+	return egressRules_;
+}
+
+void CreateTrafficMirrorFilterRequest::setEgressRules(const std::vector<EgressRules>& egressRules)
+{
+	egressRules_ = egressRules;
+	for(int dep1 = 0; dep1!= egressRules.size(); dep1++) {
+		auto egressRulesObj = egressRules.at(dep1);
+		std::string egressRulesObjStr = "EgressRules." + std::to_string(dep1 + 1);
+		setParameter(egressRulesObjStr + ".Priority", std::to_string(egressRulesObj.priority));
+		setParameter(egressRulesObjStr + ".Action", egressRulesObj.action);
+		setParameter(egressRulesObjStr + ".Protocol", egressRulesObj.protocol);
+		setParameter(egressRulesObjStr + ".DestinationCidrBlock", egressRulesObj.destinationCidrBlock);
+		setParameter(egressRulesObjStr + ".SourceCidrBlock", egressRulesObj.sourceCidrBlock);
+		setParameter(egressRulesObjStr + ".DestinationPortRange", egressRulesObj.destinationPortRange);
+		setParameter(egressRulesObjStr + ".SourcePortRange", egressRulesObj.sourcePortRange);
+	}
+}
+
+bool CreateTrafficMirrorFilterRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void CreateTrafficMirrorFilterRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string CreateTrafficMirrorFilterRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateTrafficMirrorFilterRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateTrafficMirrorFilterRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateTrafficMirrorFilterRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long CreateTrafficMirrorFilterRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateTrafficMirrorFilterRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateTrafficMirrorFilterRequest::getTrafficMirrorFilterDescription()const
+{
+	return trafficMirrorFilterDescription_;
+}
+
+void CreateTrafficMirrorFilterRequest::setTrafficMirrorFilterDescription(const std::string& trafficMirrorFilterDescription)
+{
+	trafficMirrorFilterDescription_ = trafficMirrorFilterDescription;
+	setParameter("TrafficMirrorFilterDescription", trafficMirrorFilterDescription);
+}
+

vpc/src/model/CreateTrafficMirrorFilterResult.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/vpc/model/CreateTrafficMirrorFilterResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+CreateTrafficMirrorFilterResult::CreateTrafficMirrorFilterResult() :
+	ServiceResult()
+{}
+
+CreateTrafficMirrorFilterResult::CreateTrafficMirrorFilterResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateTrafficMirrorFilterResult::~CreateTrafficMirrorFilterResult()
+{}
+
+void CreateTrafficMirrorFilterResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["TrafficMirrorFilterId"].isNull())
+		trafficMirrorFilterId_ = value["TrafficMirrorFilterId"].asString();
+
+}
+
+std::string CreateTrafficMirrorFilterResult::getTrafficMirrorFilterId()const
+{
+	return trafficMirrorFilterId_;
+}
+

vpc/src/model/CreateTrafficMirrorFilterRulesRequest.cc

@@ -0,0 +1,159 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/vpc/model/CreateTrafficMirrorFilterRulesRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateTrafficMirrorFilterRulesRequest;
+
+CreateTrafficMirrorFilterRulesRequest::CreateTrafficMirrorFilterRulesRequest() :
+	RpcServiceRequest("vpc", "2016-04-28", "CreateTrafficMirrorFilterRules")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateTrafficMirrorFilterRulesRequest::~CreateTrafficMirrorFilterRulesRequest()
+{}
+
+long CreateTrafficMirrorFilterRulesRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateTrafficMirrorFilterRulesRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string CreateTrafficMirrorFilterRulesRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateTrafficMirrorFilterRulesRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::vector<CreateTrafficMirrorFilterRulesRequest::IngressRules> CreateTrafficMirrorFilterRulesRequest::getIngressRules()const
+{
+	return ingressRules_;
+}
+
+void CreateTrafficMirrorFilterRulesRequest::setIngressRules(const std::vector<IngressRules>& ingressRules)
+{
+	ingressRules_ = ingressRules;
+	for(int dep1 = 0; dep1!= ingressRules.size(); dep1++) {
+		auto ingressRulesObj = ingressRules.at(dep1);
+		std::string ingressRulesObjStr = "IngressRules." + std::to_string(dep1 + 1);
+		setParameter(ingressRulesObjStr + ".Priority", std::to_string(ingressRulesObj.priority));
+		setParameter(ingressRulesObjStr + ".Action", ingressRulesObj.action);
+		setParameter(ingressRulesObjStr + ".Protocol", ingressRulesObj.protocol);
+		setParameter(ingressRulesObjStr + ".DestinationCidrBlock", ingressRulesObj.destinationCidrBlock);
+		setParameter(ingressRulesObjStr + ".SourceCidrBlock", ingressRulesObj.sourceCidrBlock);
+		setParameter(ingressRulesObjStr + ".DestinationPortRange", ingressRulesObj.destinationPortRange);
+		setParameter(ingressRulesObjStr + ".SourcePortRange", ingressRulesObj.sourcePortRange);
+	}
+}
+
+std::string CreateTrafficMirrorFilterRulesRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateTrafficMirrorFilterRulesRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::vector<CreateTrafficMirrorFilterRulesRequest::EgressRules> CreateTrafficMirrorFilterRulesRequest::getEgressRules()const
+{
+	return egressRules_;
+}
+
+void CreateTrafficMirrorFilterRulesRequest::setEgressRules(const std::vector<EgressRules>& egressRules)
+{
+	egressRules_ = egressRules;
+	for(int dep1 = 0; dep1!= egressRules.size(); dep1++) {
+		auto egressRulesObj = egressRules.at(dep1);
+		std::string egressRulesObjStr = "EgressRules." + std::to_string(dep1 + 1);
+		setParameter(egressRulesObjStr + ".Priority", std::to_string(egressRulesObj.priority));
+		setParameter(egressRulesObjStr + ".Action", egressRulesObj.action);
+		setParameter(egressRulesObjStr + ".Protocol", egressRulesObj.protocol);
+		setParameter(egressRulesObjStr + ".DestinationCidrBlock", egressRulesObj.destinationCidrBlock);
+		setParameter(egressRulesObjStr + ".SourceCidrBlock", egressRulesObj.sourceCidrBlock);
+		setParameter(egressRulesObjStr + ".DestinationPortRange", egressRulesObj.destinationPortRange);
+		setParameter(egressRulesObjStr + ".SourcePortRange", egressRulesObj.sourcePortRange);
+	}
+}
+
+bool CreateTrafficMirrorFilterRulesRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void CreateTrafficMirrorFilterRulesRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string CreateTrafficMirrorFilterRulesRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateTrafficMirrorFilterRulesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateTrafficMirrorFilterRulesRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateTrafficMirrorFilterRulesRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long CreateTrafficMirrorFilterRulesRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateTrafficMirrorFilterRulesRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateTrafficMirrorFilterRulesRequest::getTrafficMirrorFilterId()const
+{
+	return trafficMirrorFilterId_;
+}
+
+void CreateTrafficMirrorFilterRulesRequest::setTrafficMirrorFilterId(const std::string& trafficMirrorFilterId)
+{
+	trafficMirrorFilterId_ = trafficMirrorFilterId;
+	setParameter("TrafficMirrorFilterId", trafficMirrorFilterId);
+}
+

vpc/src/model/CreateTrafficMirrorFilterRulesResult.cc

@@ -0,0 +1,70 @@
+/*
+ * 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/vpc/model/CreateTrafficMirrorFilterRulesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+CreateTrafficMirrorFilterRulesResult::CreateTrafficMirrorFilterRulesResult() :
+	ServiceResult()
+{}
+
+CreateTrafficMirrorFilterRulesResult::CreateTrafficMirrorFilterRulesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateTrafficMirrorFilterRulesResult::~CreateTrafficMirrorFilterRulesResult()
+{}
+
+void CreateTrafficMirrorFilterRulesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allIngressRulesNode = value["IngressRules"]["IngressRule"];
+	for (auto valueIngressRulesIngressRule : allIngressRulesNode)
+	{
+		IngressRule ingressRulesObject;
+		if(!valueIngressRulesIngressRule["InstanceId"].isNull())
+			ingressRulesObject.instanceId = valueIngressRulesIngressRule["InstanceId"].asString();
+		ingressRules_.push_back(ingressRulesObject);
+	}
+	auto allEgressRulesNode = value["EgressRules"]["EgressRule"];
+	for (auto valueEgressRulesEgressRule : allEgressRulesNode)
+	{
+		EgressRule egressRulesObject;
+		if(!valueEgressRulesEgressRule["InstanceId"].isNull())
+			egressRulesObject.instanceId = valueEgressRulesEgressRule["InstanceId"].asString();
+		egressRules_.push_back(egressRulesObject);
+	}
+
+}
+
+std::vector<CreateTrafficMirrorFilterRulesResult::EgressRule> CreateTrafficMirrorFilterRulesResult::getEgressRules()const
+{
+	return egressRules_;
+}
+
+std::vector<CreateTrafficMirrorFilterRulesResult::IngressRule> CreateTrafficMirrorFilterRulesResult::getIngressRules()const
+{
+	return ingressRules_;
+}
+

vpc/src/model/CreateTrafficMirrorSessionRequest.cc

@@ -0,0 +1,218 @@
+/*
+ * 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/vpc/model/CreateTrafficMirrorSessionRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateTrafficMirrorSessionRequest;
+
+CreateTrafficMirrorSessionRequest::CreateTrafficMirrorSessionRequest() :
+	RpcServiceRequest("vpc", "2016-04-28", "CreateTrafficMirrorSession")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateTrafficMirrorSessionRequest::~CreateTrafficMirrorSessionRequest()
+{}
+
+std::string CreateTrafficMirrorSessionRequest::getTrafficMirrorTargetType()const
+{
+	return trafficMirrorTargetType_;
+}
+
+void CreateTrafficMirrorSessionRequest::setTrafficMirrorTargetType(const std::string& trafficMirrorTargetType)
+{
+	trafficMirrorTargetType_ = trafficMirrorTargetType;
+	setParameter("TrafficMirrorTargetType", trafficMirrorTargetType);
+}
+
+long CreateTrafficMirrorSessionRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateTrafficMirrorSessionRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string CreateTrafficMirrorSessionRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateTrafficMirrorSessionRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+bool CreateTrafficMirrorSessionRequest::getEnabled()const
+{
+	return enabled_;
+}
+
+void CreateTrafficMirrorSessionRequest::setEnabled(bool enabled)
+{
+	enabled_ = enabled;
+	setParameter("Enabled", enabled ? "true" : "false");
+}
+
+std::string CreateTrafficMirrorSessionRequest::getTrafficMirrorSessionName()const
+{
+	return trafficMirrorSessionName_;
+}
+
+void CreateTrafficMirrorSessionRequest::setTrafficMirrorSessionName(const std::string& trafficMirrorSessionName)
+{
+	trafficMirrorSessionName_ = trafficMirrorSessionName;
+	setParameter("TrafficMirrorSessionName", trafficMirrorSessionName);
+}
+
+std::string CreateTrafficMirrorSessionRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateTrafficMirrorSessionRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreateTrafficMirrorSessionRequest::getTrafficMirrorSessionDescription()const
+{
+	return trafficMirrorSessionDescription_;
+}
+
+void CreateTrafficMirrorSessionRequest::setTrafficMirrorSessionDescription(const std::string& trafficMirrorSessionDescription)
+{
+	trafficMirrorSessionDescription_ = trafficMirrorSessionDescription;
+	setParameter("TrafficMirrorSessionDescription", trafficMirrorSessionDescription);
+}
+
+std::vector<std::string> CreateTrafficMirrorSessionRequest::getTrafficMirrorSourceIds()const
+{
+	return trafficMirrorSourceIds_;
+}
+
+void CreateTrafficMirrorSessionRequest::setTrafficMirrorSourceIds(const std::vector<std::string>& trafficMirrorSourceIds)
+{
+	trafficMirrorSourceIds_ = trafficMirrorSourceIds;
+	for(int dep1 = 0; dep1!= trafficMirrorSourceIds.size(); dep1++) {
+		setParameter("TrafficMirrorSourceIds."+ std::to_string(dep1), trafficMirrorSourceIds.at(dep1));
+	}
+}
+
+bool CreateTrafficMirrorSessionRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void CreateTrafficMirrorSessionRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string CreateTrafficMirrorSessionRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateTrafficMirrorSessionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateTrafficMirrorSessionRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateTrafficMirrorSessionRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+int CreateTrafficMirrorSessionRequest::getPriority()const
+{
+	return priority_;
+}
+
+void CreateTrafficMirrorSessionRequest::setPriority(int priority)
+{
+	priority_ = priority;
+	setParameter("Priority", std::to_string(priority));
+}
+
+long CreateTrafficMirrorSessionRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateTrafficMirrorSessionRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateTrafficMirrorSessionRequest::getTrafficMirrorTargetId()const
+{
+	return trafficMirrorTargetId_;
+}
+
+void CreateTrafficMirrorSessionRequest::setTrafficMirrorTargetId(const std::string& trafficMirrorTargetId)
+{
+	trafficMirrorTargetId_ = trafficMirrorTargetId;
+	setParameter("TrafficMirrorTargetId", trafficMirrorTargetId);
+}
+
+std::string CreateTrafficMirrorSessionRequest::getTrafficMirrorFilterId()const
+{
+	return trafficMirrorFilterId_;
+}
+
+void CreateTrafficMirrorSessionRequest::setTrafficMirrorFilterId(const std::string& trafficMirrorFilterId)
+{
+	trafficMirrorFilterId_ = trafficMirrorFilterId;
+	setParameter("TrafficMirrorFilterId", trafficMirrorFilterId);
+}
+
+int CreateTrafficMirrorSessionRequest::getPacketLength()const
+{
+	return packetLength_;
+}
+
+void CreateTrafficMirrorSessionRequest::setPacketLength(int packetLength)
+{
+	packetLength_ = packetLength;
+	setParameter("PacketLength", std::to_string(packetLength));
+}
+
+int CreateTrafficMirrorSessionRequest::getVirtualNetworkId()const
+{
+	return virtualNetworkId_;
+}
+
+void CreateTrafficMirrorSessionRequest::setVirtualNetworkId(int virtualNetworkId)
+{
+	virtualNetworkId_ = virtualNetworkId;
+	setParameter("VirtualNetworkId", std::to_string(virtualNetworkId));
+}
+

vpc/src/model/CreateTrafficMirrorSessionResult.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/vpc/model/CreateTrafficMirrorSessionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+CreateTrafficMirrorSessionResult::CreateTrafficMirrorSessionResult() :
+	ServiceResult()
+{}
+
+CreateTrafficMirrorSessionResult::CreateTrafficMirrorSessionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateTrafficMirrorSessionResult::~CreateTrafficMirrorSessionResult()
+{}
+
+void CreateTrafficMirrorSessionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["TrafficMirrorSessionId"].isNull())
+		trafficMirrorSessionId_ = value["TrafficMirrorSessionId"].asString();
+
+}
+
+std::string CreateTrafficMirrorSessionResult::getTrafficMirrorSessionId()const
+{
+	return trafficMirrorSessionId_;
+}
+

vpc/src/model/CreateVSwitchRequest.cc

@@ -115,6 +115,17 @@ void CreateVSwitchRequest::setIpv6CidrBlock(int ipv6CidrBlock)
 	setParameter("Ipv6CidrBlock", std::to_string(ipv6CidrBlock));
 }
 
+std::string CreateVSwitchRequest::getVpcIpv6CidrBlock()const
+{
+	return vpcIpv6CidrBlock_;
+}
+
+void CreateVSwitchRequest::setVpcIpv6CidrBlock(const std::string& vpcIpv6CidrBlock)
+{
+	vpcIpv6CidrBlock_ = vpcIpv6CidrBlock;
+	setParameter("VpcIpv6CidrBlock", vpcIpv6CidrBlock);
+}
+
 std::string CreateVSwitchRequest::getVpcId()const
 {
 	return vpcId_;

vpc/src/model/CreateVbrHaRequest.cc

@@ -0,0 +1,150 @@
+/*
+ * 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/vpc/model/CreateVbrHaRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateVbrHaRequest;
+
+CreateVbrHaRequest::CreateVbrHaRequest() :
+	RpcServiceRequest("vpc", "2016-04-28", "CreateVbrHa")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateVbrHaRequest::~CreateVbrHaRequest()
+{}
+
+long CreateVbrHaRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateVbrHaRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string CreateVbrHaRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateVbrHaRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string CreateVbrHaRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateVbrHaRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+std::string CreateVbrHaRequest::getVbrId()const
+{
+	return vbrId_;
+}
+
+void CreateVbrHaRequest::setVbrId(const std::string& vbrId)
+{
+	vbrId_ = vbrId;
+	setParameter("VbrId", vbrId);
+}
+
+std::string CreateVbrHaRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateVbrHaRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+bool CreateVbrHaRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void CreateVbrHaRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string CreateVbrHaRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateVbrHaRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateVbrHaRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateVbrHaRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long CreateVbrHaRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateVbrHaRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateVbrHaRequest::getPeerVbrId()const
+{
+	return peerVbrId_;
+}
+
+void CreateVbrHaRequest::setPeerVbrId(const std::string& peerVbrId)
+{
+	peerVbrId_ = peerVbrId;
+	setParameter("PeerVbrId", peerVbrId);
+}
+
+std::string CreateVbrHaRequest::getName()const
+{
+	return name_;
+}
+
+void CreateVbrHaRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+

vpc/src/model/CreateVbrHaResult.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/vpc/model/CreateVbrHaResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+CreateVbrHaResult::CreateVbrHaResult() :
+	ServiceResult()
+{}
+
+CreateVbrHaResult::CreateVbrHaResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateVbrHaResult::~CreateVbrHaResult()
+{}
+
+void CreateVbrHaResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["VbrHaId"].isNull())
+		vbrHaId_ = value["VbrHaId"].asString();
+
+}
+
+std::string CreateVbrHaResult::getVbrHaId()const
+{
+	return vbrHaId_;
+}
+

vpc/src/model/CreateVirtualBorderRouterRequest.cc

@@ -71,6 +71,17 @@ void CreateVirtualBorderRouterRequest::setClientToken(const std::string& clientT
 	setParameter("ClientToken", clientToken);
 }
 
+bool CreateVirtualBorderRouterRequest::getEnableIpv6()const
+{
+	return enableIpv6_;
+}
+
+void CreateVirtualBorderRouterRequest::setEnableIpv6(bool enableIpv6)
+{
+	enableIpv6_ = enableIpv6;
+	setParameter("EnableIpv6", enableIpv6 ? "true" : "false");
+}
+
 std::string CreateVirtualBorderRouterRequest::getDescription()const
 {
 	return description_;
@@ -93,6 +104,17 @@ void CreateVirtualBorderRouterRequest::setPeerGatewayIp(const std::string& peerG
 	setParameter("PeerGatewayIp", peerGatewayIp);
 }
 
+std::string CreateVirtualBorderRouterRequest::getPeerIpv6GatewayIp()const
+{
+	return peerIpv6GatewayIp_;
+}
+
+void CreateVirtualBorderRouterRequest::setPeerIpv6GatewayIp(const std::string& peerIpv6GatewayIp)
+{
+	peerIpv6GatewayIp_ = peerIpv6GatewayIp;
+	setParameter("PeerIpv6GatewayIp", peerIpv6GatewayIp);
+}
+
 std::string CreateVirtualBorderRouterRequest::getPeeringSubnetMask()const
 {
 	return peeringSubnetMask_;
@@ -126,6 +148,17 @@ void CreateVirtualBorderRouterRequest::setLocalGatewayIp(const std::string& loca
 	setParameter("LocalGatewayIp", localGatewayIp);
 }
 
+std::string CreateVirtualBorderRouterRequest::getPeeringIpv6SubnetMask()const
+{
+	return peeringIpv6SubnetMask_;
+}
+
+void CreateVirtualBorderRouterRequest::setPeeringIpv6SubnetMask(const std::string& peeringIpv6SubnetMask)
+{
+	peeringIpv6SubnetMask_ = peeringIpv6SubnetMask;
+	setParameter("PeeringIpv6SubnetMask", peeringIpv6SubnetMask);
+}
+
 std::string CreateVirtualBorderRouterRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -137,6 +170,17 @@ void CreateVirtualBorderRouterRequest::setResourceOwnerAccount(const std::string
 	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
+long CreateVirtualBorderRouterRequest::getBandwidth()const
+{
+	return bandwidth_;
+}
+
+void CreateVirtualBorderRouterRequest::setBandwidth(long bandwidth)
+{
+	bandwidth_ = bandwidth;
+	setParameter("Bandwidth", std::to_string(bandwidth));
+}
+
 std::string CreateVirtualBorderRouterRequest::getOwnerAccount()const
 {
 	return ownerAccount_;
@@ -170,6 +214,17 @@ void CreateVirtualBorderRouterRequest::setPhysicalConnectionId(const std::string
 	setParameter("PhysicalConnectionId", physicalConnectionId);
 }
 
+std::string CreateVirtualBorderRouterRequest::getLocalIpv6GatewayIp()const
+{
+	return localIpv6GatewayIp_;
+}
+
+void CreateVirtualBorderRouterRequest::setLocalIpv6GatewayIp(const std::string& localIpv6GatewayIp)
+{
+	localIpv6GatewayIp_ = localIpv6GatewayIp;
+	setParameter("LocalIpv6GatewayIp", localIpv6GatewayIp);
+}
+
 std::string CreateVirtualBorderRouterRequest::getName()const
 {
 	return name_;

vpc/src/model/CreateVpcRequest.cc

@@ -104,6 +104,17 @@ void CreateVpcRequest::setRegionId(const std::string& regionId)
 	setParameter("RegionId", regionId);
 }
 
+std::string CreateVpcRequest::getIpv6Isp()const
+{
+	return ipv6Isp_;
+}
+
+void CreateVpcRequest::setIpv6Isp(const std::string& ipv6Isp)
+{
+	ipv6Isp_ = ipv6Isp;
+	setParameter("Ipv6Isp", ipv6Isp);
+}
+
 std::string CreateVpcRequest::getUserCidr()const
 {
 	return userCidr_;

vpc/src/model/CreateVpnConnectionRequest.cc

@@ -82,6 +82,17 @@ void CreateVpnConnectionRequest::setIpsecConfig(const std::string& ipsecConfig)
 	setParameter("IpsecConfig", ipsecConfig);
 }
 
+std::string CreateVpnConnectionRequest::getBgpConfig()const
+{
+	return bgpConfig_;
+}
+
+void CreateVpnConnectionRequest::setBgpConfig(const std::string& bgpConfig)
+{
+	bgpConfig_ = bgpConfig;
+	setParameter("BgpConfig", bgpConfig);
+}
+
 std::string CreateVpnConnectionRequest::getHealthCheckConfig()const
 {
 	return healthCheckConfig_;
@@ -203,6 +214,17 @@ void CreateVpnConnectionRequest::setEnableDpd(bool enableDpd)
 	setParameter("EnableDpd", enableDpd ? "true" : "false");
 }
 
+std::string CreateVpnConnectionRequest::getRemoteCaCertificate()const
+{
+	return remoteCaCertificate_;
+}
+
+void CreateVpnConnectionRequest::setRemoteCaCertificate(const std::string& remoteCaCertificate)
+{
+	remoteCaCertificate_ = remoteCaCertificate;
+	setParameter("RemoteCaCertificate", remoteCaCertificate);
+}
+
 std::string CreateVpnConnectionRequest::getName()const
 {
 	return name_;

vpc/src/model/CreateVpnGatewayRequest.cc

@@ -38,6 +38,17 @@ void CreateVpnGatewayRequest::setResourceOwnerId(long resourceOwnerId)
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+std::string CreateVpnGatewayRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateVpnGatewayRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
 bool CreateVpnGatewayRequest::getEnableIpsec()const
 {
 	return enableIpsec_;
@@ -137,6 +148,17 @@ void CreateVpnGatewayRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
+std::string CreateVpnGatewayRequest::getVpnType()const
+{
+	return vpnType_;
+}
+
+void CreateVpnGatewayRequest::setVpnType(const std::string& vpnType)
+{
+	vpnType_ = vpnType;
+	setParameter("VpnType", vpnType);
+}
+
 std::string CreateVpnGatewayRequest::getVSwitchId()const
 {
 	return vSwitchId_;

vpc/src/model/DeleteBandwidthPackageRequest.cc

@@ -1,106 +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/vpc/model/DeleteBandwidthPackageRequest.h>
-
-using AlibabaCloud::Vpc::Model::DeleteBandwidthPackageRequest;
-
-DeleteBandwidthPackageRequest::DeleteBandwidthPackageRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "DeleteBandwidthPackage")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DeleteBandwidthPackageRequest::~DeleteBandwidthPackageRequest()
-{}
-
-long DeleteBandwidthPackageRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
-}
-
-void DeleteBandwidthPackageRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
-}
-
-std::string DeleteBandwidthPackageRequest::getRegionId()const
-{
-	return regionId_;
-}
-
-void DeleteBandwidthPackageRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
-}
-
-std::string DeleteBandwidthPackageRequest::getBandwidthPackageId()const
-{
-	return bandwidthPackageId_;
-}
-
-void DeleteBandwidthPackageRequest::setBandwidthPackageId(const std::string& bandwidthPackageId)
-{
-	bandwidthPackageId_ = bandwidthPackageId;
-	setParameter("BandwidthPackageId", bandwidthPackageId);
-}
-
-std::string DeleteBandwidthPackageRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
-}
-
-void DeleteBandwidthPackageRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
-}
-
-std::string DeleteBandwidthPackageRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
-}
-
-void DeleteBandwidthPackageRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
-}
-
-long DeleteBandwidthPackageRequest::getOwnerId()const
-{
-	return ownerId_;
-}
-
-void DeleteBandwidthPackageRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
-}
-
-bool DeleteBandwidthPackageRequest::getForce()const
-{
-	return force_;
-}
-
-void DeleteBandwidthPackageRequest::setForce(bool force)
-{
-	force_ = force;
-	setParameter("Force", force ? "true" : "false");
-}
-

vpc/src/model/DeleteDhcpOptionsSetRequest.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/vpc/model/DeleteDhcpOptionsSetRequest.h>
+
+using AlibabaCloud::Vpc::Model::DeleteDhcpOptionsSetRequest;
+
+DeleteDhcpOptionsSetRequest::DeleteDhcpOptionsSetRequest() :
+	RpcServiceRequest("vpc", "2016-04-28", "DeleteDhcpOptionsSet")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteDhcpOptionsSetRequest::~DeleteDhcpOptionsSetRequest()
+{}
+
+long DeleteDhcpOptionsSetRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DeleteDhcpOptionsSetRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DeleteDhcpOptionsSetRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void DeleteDhcpOptionsSetRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string DeleteDhcpOptionsSetRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteDhcpOptionsSetRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+bool DeleteDhcpOptionsSetRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void DeleteDhcpOptionsSetRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string DeleteDhcpOptionsSetRequest::getDhcpOptionsSetId()const
+{
+	return dhcpOptionsSetId_;
+}
+
+void DeleteDhcpOptionsSetRequest::setDhcpOptionsSetId(const std::string& dhcpOptionsSetId)
+{
+	dhcpOptionsSetId_ = dhcpOptionsSetId;
+	setParameter("DhcpOptionsSetId", dhcpOptionsSetId);
+}
+
+std::string DeleteDhcpOptionsSetRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DeleteDhcpOptionsSetRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DeleteDhcpOptionsSetRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DeleteDhcpOptionsSetRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DeleteDhcpOptionsSetRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DeleteDhcpOptionsSetRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

vpc/src/model/DeleteDhcpOptionsSetResult.cc

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

vpc/src/model/DeleteIpsecServerRequest.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/vpc/model/DeleteIpsecServerRequest.h>
+
+using AlibabaCloud::Vpc::Model::DeleteIpsecServerRequest;
+
+DeleteIpsecServerRequest::DeleteIpsecServerRequest() :
+	RpcServiceRequest("vpc", "2016-04-28", "DeleteIpsecServer")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteIpsecServerRequest::~DeleteIpsecServerRequest()
+{}
+
+long DeleteIpsecServerRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DeleteIpsecServerRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DeleteIpsecServerRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void DeleteIpsecServerRequest::setDryRun(const std::string& dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun);
+}
+
+std::string DeleteIpsecServerRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void DeleteIpsecServerRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string DeleteIpsecServerRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DeleteIpsecServerRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+std::string DeleteIpsecServerRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteIpsecServerRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DeleteIpsecServerRequest::getIpsecServerId()const
+{
+	return ipsecServerId_;
+}
+
+void DeleteIpsecServerRequest::setIpsecServerId(const std::string& ipsecServerId)
+{
+	ipsecServerId_ = ipsecServerId;
+	setParameter("IpsecServerId", ipsecServerId);
+}
+

vpc/src/model/DeleteIpsecServerResult.cc

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

vpc/src/model/DeleteTrafficMirrorFilterRequest.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/vpc/model/DeleteTrafficMirrorFilterRequest.h>
+
+using AlibabaCloud::Vpc::Model::DeleteTrafficMirrorFilterRequest;
+
+DeleteTrafficMirrorFilterRequest::DeleteTrafficMirrorFilterRequest() :
+	RpcServiceRequest("vpc", "2016-04-28", "DeleteTrafficMirrorFilter")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteTrafficMirrorFilterRequest::~DeleteTrafficMirrorFilterRequest()
+{}
+
+long DeleteTrafficMirrorFilterRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DeleteTrafficMirrorFilterRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DeleteTrafficMirrorFilterRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void DeleteTrafficMirrorFilterRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string DeleteTrafficMirrorFilterRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteTrafficMirrorFilterRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+bool DeleteTrafficMirrorFilterRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void DeleteTrafficMirrorFilterRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string DeleteTrafficMirrorFilterRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DeleteTrafficMirrorFilterRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DeleteTrafficMirrorFilterRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DeleteTrafficMirrorFilterRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DeleteTrafficMirrorFilterRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DeleteTrafficMirrorFilterRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DeleteTrafficMirrorFilterRequest::getTrafficMirrorFilterId()const
+{
+	return trafficMirrorFilterId_;
+}
+
+void DeleteTrafficMirrorFilterRequest::setTrafficMirrorFilterId(const std::string& trafficMirrorFilterId)
+{
+	trafficMirrorFilterId_ = trafficMirrorFilterId;
+	setParameter("TrafficMirrorFilterId", trafficMirrorFilterId);
+}
+

vpc/src/model/DeleteTrafficMirrorFilterResult.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/vpc/model/DeleteTrafficMirrorFilterResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+DeleteTrafficMirrorFilterResult::DeleteTrafficMirrorFilterResult() :
+	ServiceResult()
+{}
+
+DeleteTrafficMirrorFilterResult::DeleteTrafficMirrorFilterResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteTrafficMirrorFilterResult::~DeleteTrafficMirrorFilterResult()
+{}
+
+void DeleteTrafficMirrorFilterResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

vpc/src/model/DeleteTrafficMirrorFilterRulesRequest.cc

@@ -0,0 +1,130 @@
+/*
+ * 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/vpc/model/DeleteTrafficMirrorFilterRulesRequest.h>
+
+using AlibabaCloud::Vpc::Model::DeleteTrafficMirrorFilterRulesRequest;
+
+DeleteTrafficMirrorFilterRulesRequest::DeleteTrafficMirrorFilterRulesRequest() :
+	RpcServiceRequest("vpc", "2016-04-28", "DeleteTrafficMirrorFilterRules")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteTrafficMirrorFilterRulesRequest::~DeleteTrafficMirrorFilterRulesRequest()
+{}
+
+long DeleteTrafficMirrorFilterRulesRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DeleteTrafficMirrorFilterRulesRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DeleteTrafficMirrorFilterRulesRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void DeleteTrafficMirrorFilterRulesRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string DeleteTrafficMirrorFilterRulesRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteTrafficMirrorFilterRulesRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+bool DeleteTrafficMirrorFilterRulesRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void DeleteTrafficMirrorFilterRulesRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string DeleteTrafficMirrorFilterRulesRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DeleteTrafficMirrorFilterRulesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DeleteTrafficMirrorFilterRulesRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DeleteTrafficMirrorFilterRulesRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DeleteTrafficMirrorFilterRulesRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DeleteTrafficMirrorFilterRulesRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DeleteTrafficMirrorFilterRulesRequest::getTrafficMirrorFilterId()const
+{
+	return trafficMirrorFilterId_;
+}
+
+void DeleteTrafficMirrorFilterRulesRequest::setTrafficMirrorFilterId(const std::string& trafficMirrorFilterId)
+{
+	trafficMirrorFilterId_ = trafficMirrorFilterId;
+	setParameter("TrafficMirrorFilterId", trafficMirrorFilterId);
+}
+
+std::vector<std::string> DeleteTrafficMirrorFilterRulesRequest::getTrafficMirrorFilterRuleIds()const
+{
+	return trafficMirrorFilterRuleIds_;
+}
+
+void DeleteTrafficMirrorFilterRulesRequest::setTrafficMirrorFilterRuleIds(const std::vector<std::string>& trafficMirrorFilterRuleIds)
+{
+	trafficMirrorFilterRuleIds_ = trafficMirrorFilterRuleIds;
+	for(int dep1 = 0; dep1!= trafficMirrorFilterRuleIds.size(); dep1++) {
+		setParameter("TrafficMirrorFilterRuleIds."+ std::to_string(dep1), trafficMirrorFilterRuleIds.at(dep1));
+	}
+}
+

vpc/src/model/DeleteTrafficMirrorFilterRulesResult.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/vpc/model/DeleteTrafficMirrorFilterRulesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+DeleteTrafficMirrorFilterRulesResult::DeleteTrafficMirrorFilterRulesResult() :
+	ServiceResult()
+{}
+
+DeleteTrafficMirrorFilterRulesResult::DeleteTrafficMirrorFilterRulesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteTrafficMirrorFilterRulesResult::~DeleteTrafficMirrorFilterRulesResult()
+{}
+
+void DeleteTrafficMirrorFilterRulesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

vpc/src/model/DeleteTrafficMirrorSessionRequest.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/vpc/model/DeleteTrafficMirrorSessionRequest.h>
+
+using AlibabaCloud::Vpc::Model::DeleteTrafficMirrorSessionRequest;
+
+DeleteTrafficMirrorSessionRequest::DeleteTrafficMirrorSessionRequest() :
+	RpcServiceRequest("vpc", "2016-04-28", "DeleteTrafficMirrorSession")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteTrafficMirrorSessionRequest::~DeleteTrafficMirrorSessionRequest()
+{}
+
+long DeleteTrafficMirrorSessionRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DeleteTrafficMirrorSessionRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DeleteTrafficMirrorSessionRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void DeleteTrafficMirrorSessionRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string DeleteTrafficMirrorSessionRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteTrafficMirrorSessionRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+bool DeleteTrafficMirrorSessionRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void DeleteTrafficMirrorSessionRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string DeleteTrafficMirrorSessionRequest::getTrafficMirrorSessionId()const
+{
+	return trafficMirrorSessionId_;
+}
+
+void DeleteTrafficMirrorSessionRequest::setTrafficMirrorSessionId(const std::string& trafficMirrorSessionId)
+{
+	trafficMirrorSessionId_ = trafficMirrorSessionId;
+	setParameter("TrafficMirrorSessionId", trafficMirrorSessionId);
+}
+
+std::string DeleteTrafficMirrorSessionRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DeleteTrafficMirrorSessionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DeleteTrafficMirrorSessionRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DeleteTrafficMirrorSessionRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DeleteTrafficMirrorSessionRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DeleteTrafficMirrorSessionRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

vpc/src/model/DeleteTrafficMirrorSessionResult.cc

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

vpc/src/model/DeleteVbrHaRequest.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/vpc/model/DeleteVbrHaRequest.h>
+
+using AlibabaCloud::Vpc::Model::DeleteVbrHaRequest;
+
+DeleteVbrHaRequest::DeleteVbrHaRequest() :
+	RpcServiceRequest("vpc", "2016-04-28", "DeleteVbrHa")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteVbrHaRequest::~DeleteVbrHaRequest()
+{}
+
+long DeleteVbrHaRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DeleteVbrHaRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DeleteVbrHaRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void DeleteVbrHaRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string DeleteVbrHaRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteVbrHaRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+bool DeleteVbrHaRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void DeleteVbrHaRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string DeleteVbrHaRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DeleteVbrHaRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DeleteVbrHaRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DeleteVbrHaRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DeleteVbrHaRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DeleteVbrHaRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DeleteVbrHaRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void DeleteVbrHaRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+

vpc/src/model/DeleteVbrHaResult.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/vpc/model/DeleteVbrHaResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+DeleteVbrHaResult::DeleteVbrHaResult() :
+	ServiceResult()
+{}
+
+DeleteVbrHaResult::DeleteVbrHaResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteVbrHaResult::~DeleteVbrHaResult()
+{}
+
+void DeleteVbrHaResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

vpc/src/model/DescribeAccessPointsResult.cc

@@ -59,6 +59,16 @@ void DescribeAccessPointsResult::parse(const std::string &payload)
 			accessPointSetObject.name = valueAccessPointSetAccessPointType["Name"].asString();
 		if(!valueAccessPointSetAccessPointType["Description"].isNull())
 			accessPointSetObject.description = valueAccessPointSetAccessPointType["Description"].asString();
+		auto allAccessPointFeatureModelsNode = valueAccessPointSetAccessPointType["AccessPointFeatureModels"]["AccessPointFeatureModel"];
+		for (auto valueAccessPointSetAccessPointTypeAccessPointFeatureModelsAccessPointFeatureModel : allAccessPointFeatureModelsNode)
+		{
+			AccessPointType::AccessPointFeatureModel accessPointFeatureModelsObject;
+			if(!valueAccessPointSetAccessPointTypeAccessPointFeatureModelsAccessPointFeatureModel["FeatureKey"].isNull())
+				accessPointFeatureModelsObject.featureKey = valueAccessPointSetAccessPointTypeAccessPointFeatureModelsAccessPointFeatureModel["FeatureKey"].asString();
+			if(!valueAccessPointSetAccessPointTypeAccessPointFeatureModelsAccessPointFeatureModel["FeatureValue"].isNull())
+				accessPointFeatureModelsObject.featureValue = valueAccessPointSetAccessPointTypeAccessPointFeatureModelsAccessPointFeatureModel["FeatureValue"].asString();
+			accessPointSetObject.accessPointFeatureModels.push_back(accessPointFeatureModelsObject);
+		}
 		accessPointSet_.push_back(accessPointSetObject);
 	}
 	if(!value["PageNumber"].isNull())

vpc/src/model/DescribeBandwidthPackagesRequest.cc

@@ -1,128 +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/vpc/model/DescribeBandwidthPackagesRequest.h>
-
-using AlibabaCloud::Vpc::Model::DescribeBandwidthPackagesRequest;
-
-DescribeBandwidthPackagesRequest::DescribeBandwidthPackagesRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "DescribeBandwidthPackages")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeBandwidthPackagesRequest::~DescribeBandwidthPackagesRequest()
-{}
-
-long DescribeBandwidthPackagesRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
-}
-
-void DescribeBandwidthPackagesRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
-}
-
-int DescribeBandwidthPackagesRequest::getPageNumber()const
-{
-	return pageNumber_;
-}
-
-void DescribeBandwidthPackagesRequest::setPageNumber(int pageNumber)
-{
-	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
-}
-
-std::string DescribeBandwidthPackagesRequest::getRegionId()const
-{
-	return regionId_;
-}
-
-void DescribeBandwidthPackagesRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
-}
-
-int DescribeBandwidthPackagesRequest::getPageSize()const
-{
-	return pageSize_;
-}
-
-void DescribeBandwidthPackagesRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
-}
-
-std::string DescribeBandwidthPackagesRequest::getNatGatewayId()const
-{
-	return natGatewayId_;
-}
-
-void DescribeBandwidthPackagesRequest::setNatGatewayId(const std::string& natGatewayId)
-{
-	natGatewayId_ = natGatewayId;
-	setParameter("NatGatewayId", natGatewayId);
-}
-
-std::string DescribeBandwidthPackagesRequest::getBandwidthPackageId()const
-{
-	return bandwidthPackageId_;
-}
-
-void DescribeBandwidthPackagesRequest::setBandwidthPackageId(const std::string& bandwidthPackageId)
-{
-	bandwidthPackageId_ = bandwidthPackageId;
-	setParameter("BandwidthPackageId", bandwidthPackageId);
-}
-
-std::string DescribeBandwidthPackagesRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
-}
-
-void DescribeBandwidthPackagesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
-}
-
-std::string DescribeBandwidthPackagesRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
-}
-
-void DescribeBandwidthPackagesRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
-}
-
-long DescribeBandwidthPackagesRequest::getOwnerId()const
-{
-	return ownerId_;
-}
-
-void DescribeBandwidthPackagesRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
-}
-

vpc/src/model/DescribeBandwidthPackagesResult.cc

@@ -1,118 +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/vpc/model/DescribeBandwidthPackagesResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Vpc;
-using namespace AlibabaCloud::Vpc::Model;
-
-DescribeBandwidthPackagesResult::DescribeBandwidthPackagesResult() :
-	ServiceResult()
-{}
-
-DescribeBandwidthPackagesResult::DescribeBandwidthPackagesResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeBandwidthPackagesResult::~DescribeBandwidthPackagesResult()
-{}
-
-void DescribeBandwidthPackagesResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allBandwidthPackagesNode = value["BandwidthPackages"]["BandwidthPackage"];
-	for (auto valueBandwidthPackagesBandwidthPackage : allBandwidthPackagesNode)
-	{
-		BandwidthPackage bandwidthPackagesObject;
-		if(!valueBandwidthPackagesBandwidthPackage["BandwidthPackageId"].isNull())
-			bandwidthPackagesObject.bandwidthPackageId = valueBandwidthPackagesBandwidthPackage["BandwidthPackageId"].asString();
-		if(!valueBandwidthPackagesBandwidthPackage["RegionId"].isNull())
-			bandwidthPackagesObject.regionId = valueBandwidthPackagesBandwidthPackage["RegionId"].asString();
-		if(!valueBandwidthPackagesBandwidthPackage["Name"].isNull())
-			bandwidthPackagesObject.name = valueBandwidthPackagesBandwidthPackage["Name"].asString();
-		if(!valueBandwidthPackagesBandwidthPackage["Description"].isNull())
-			bandwidthPackagesObject.description = valueBandwidthPackagesBandwidthPackage["Description"].asString();
-		if(!valueBandwidthPackagesBandwidthPackage["ZoneId"].isNull())
-			bandwidthPackagesObject.zoneId = valueBandwidthPackagesBandwidthPackage["ZoneId"].asString();
-		if(!valueBandwidthPackagesBandwidthPackage["NatGatewayId"].isNull())
-			bandwidthPackagesObject.natGatewayId = valueBandwidthPackagesBandwidthPackage["NatGatewayId"].asString();
-		if(!valueBandwidthPackagesBandwidthPackage["Bandwidth"].isNull())
-			bandwidthPackagesObject.bandwidth = valueBandwidthPackagesBandwidthPackage["Bandwidth"].asString();
-		if(!valueBandwidthPackagesBandwidthPackage["InstanceChargeType"].isNull())
-			bandwidthPackagesObject.instanceChargeType = valueBandwidthPackagesBandwidthPackage["InstanceChargeType"].asString();
-		if(!valueBandwidthPackagesBandwidthPackage["InternetChargeType"].isNull())
-			bandwidthPackagesObject.internetChargeType = valueBandwidthPackagesBandwidthPackage["InternetChargeType"].asString();
-		if(!valueBandwidthPackagesBandwidthPackage["BusinessStatus"].isNull())
-			bandwidthPackagesObject.businessStatus = valueBandwidthPackagesBandwidthPackage["BusinessStatus"].asString();
-		if(!valueBandwidthPackagesBandwidthPackage["IpCount"].isNull())
-			bandwidthPackagesObject.ipCount = valueBandwidthPackagesBandwidthPackage["IpCount"].asString();
-		if(!valueBandwidthPackagesBandwidthPackage["CreationTime"].isNull())
-			bandwidthPackagesObject.creationTime = valueBandwidthPackagesBandwidthPackage["CreationTime"].asString();
-		if(!valueBandwidthPackagesBandwidthPackage["Status"].isNull())
-			bandwidthPackagesObject.status = valueBandwidthPackagesBandwidthPackage["Status"].asString();
-		if(!valueBandwidthPackagesBandwidthPackage["ISP"].isNull())
-			bandwidthPackagesObject.iSP = valueBandwidthPackagesBandwidthPackage["ISP"].asString();
-		auto allPublicIpAddressesNode = allBandwidthPackagesNode["PublicIpAddresses"]["PublicIpAddresse"];
-		for (auto allBandwidthPackagesNodePublicIpAddressesPublicIpAddresse : allPublicIpAddressesNode)
-		{
-			BandwidthPackage::PublicIpAddresse publicIpAddressesObject;
-			if(!allBandwidthPackagesNodePublicIpAddressesPublicIpAddresse["AllocationId"].isNull())
-				publicIpAddressesObject.allocationId = allBandwidthPackagesNodePublicIpAddressesPublicIpAddresse["AllocationId"].asString();
-			if(!allBandwidthPackagesNodePublicIpAddressesPublicIpAddresse["IpAddress"].isNull())
-				publicIpAddressesObject.ipAddress = allBandwidthPackagesNodePublicIpAddressesPublicIpAddresse["IpAddress"].asString();
-			if(!allBandwidthPackagesNodePublicIpAddressesPublicIpAddresse["UsingStatus"].isNull())
-				publicIpAddressesObject.usingStatus = allBandwidthPackagesNodePublicIpAddressesPublicIpAddresse["UsingStatus"].asString();
-			if(!allBandwidthPackagesNodePublicIpAddressesPublicIpAddresse["ApAccessEnabled"].isNull())
-				publicIpAddressesObject.apAccessEnabled = allBandwidthPackagesNodePublicIpAddressesPublicIpAddresse["ApAccessEnabled"].asString() == "true";
-			bandwidthPackagesObject.publicIpAddresses.push_back(publicIpAddressesObject);
-		}
-		bandwidthPackages_.push_back(bandwidthPackagesObject);
-	}
-	if(!value["TotalCount"].isNull())
-		totalCount_ = std::stoi(value["TotalCount"].asString());
-	if(!value["PageNumber"].isNull())
-		pageNumber_ = std::stoi(value["PageNumber"].asString());
-	if(!value["PageSize"].isNull())
-		pageSize_ = std::stoi(value["PageSize"].asString());
-
-}
-
-int DescribeBandwidthPackagesResult::getTotalCount()const
-{
-	return totalCount_;
-}
-
-int DescribeBandwidthPackagesResult::getPageSize()const
-{
-	return pageSize_;
-}
-
-int DescribeBandwidthPackagesResult::getPageNumber()const
-{
-	return pageNumber_;
-}
-
-std::vector<DescribeBandwidthPackagesResult::BandwidthPackage> DescribeBandwidthPackagesResult::getBandwidthPackages()const
-{
-	return bandwidthPackages_;
-}
-

vpc/src/model/DescribeBgpGroupsResult.cc

@@ -69,6 +69,8 @@ void DescribeBgpGroupsResult::parse(const std::string &payload)
 			bgpGroupsObject.routeLimit = valueBgpGroupsBgpGroup["RouteLimit"].asString();
 		if(!valueBgpGroupsBgpGroup["RegionId"].isNull())
 			bgpGroupsObject.regionId = valueBgpGroupsBgpGroup["RegionId"].asString();
+		if(!valueBgpGroupsBgpGroup["IpVersion"].isNull())
+			bgpGroupsObject.ipVersion = valueBgpGroupsBgpGroup["IpVersion"].asString();
 		bgpGroups_.push_back(bgpGroupsObject);
 	}
 	if(!value["TotalCount"].isNull())

vpc/src/model/DescribeBgpPeersResult.cc

@@ -77,6 +77,10 @@ void DescribeBgpPeersResult::parse(const std::string &payload)
 			bgpPeersObject.regionId = valueBgpPeersBgpPeer["RegionId"].asString();
 		if(!valueBgpPeersBgpPeer["EnableBfd"].isNull())
 			bgpPeersObject.enableBfd = valueBgpPeersBgpPeer["EnableBfd"].asString() == "true";
+		if(!valueBgpPeersBgpPeer["IpVersion"].isNull())
+			bgpPeersObject.ipVersion = valueBgpPeersBgpPeer["IpVersion"].asString();
+		if(!valueBgpPeersBgpPeer["BfdMultiHop"].isNull())
+			bgpPeersObject.bfdMultiHop = std::stoi(valueBgpPeersBgpPeer["BfdMultiHop"].asString());
 		bgpPeers_.push_back(bgpPeersObject);
 	}
 	if(!value["TotalCount"].isNull())

vpc/src/model/DescribeCommonBandwidthPackagesRequest.cc

@@ -93,6 +93,22 @@ void DescribeCommonBandwidthPackagesRequest::setPageSize(int pageSize)
 	setParameter("PageSize", std::to_string(pageSize));
 }
 
+std::vector<DescribeCommonBandwidthPackagesRequest::Tag> DescribeCommonBandwidthPackagesRequest::getTag()const
+{
+	return tag_;
+}
+
+void DescribeCommonBandwidthPackagesRequest::setTag(const std::vector<Tag>& tag)
+{
+	tag_ = tag;
+	for(int dep1 = 0; dep1!= tag.size(); dep1++) {
+		auto tagObj = tag.at(dep1);
+		std::string tagObjStr = "Tag." + std::to_string(dep1 + 1);
+		setParameter(tagObjStr + ".Value", tagObj.value);
+		setParameter(tagObjStr + ".Key", tagObj.key);
+	}
+}
+
 std::string DescribeCommonBandwidthPackagesRequest::getBandwidthPackageId()const
 {
 	return bandwidthPackageId_;
@@ -104,6 +120,17 @@ void DescribeCommonBandwidthPackagesRequest::setBandwidthPackageId(const std::st
 	setParameter("BandwidthPackageId", bandwidthPackageId);
 }
 
+bool DescribeCommonBandwidthPackagesRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void DescribeCommonBandwidthPackagesRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
 std::string DescribeCommonBandwidthPackagesRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;

vpc/src/model/DescribeCommonBandwidthPackagesResult.cc

@@ -83,14 +83,18 @@ void DescribeCommonBandwidthPackagesResult::parse(const std::string &payload)
 			commonBandwidthPackagesObject.iSP = valueCommonBandwidthPackagesCommonBandwidthPackage["ISP"].asString();
 		if(!valueCommonBandwidthPackagesCommonBandwidthPackage["DeletionProtection"].isNull())
 			commonBandwidthPackagesObject.deletionProtection = valueCommonBandwidthPackagesCommonBandwidthPackage["DeletionProtection"].asString() == "true";
-		auto allPublicIpAddressesNode = allCommonBandwidthPackagesNode["PublicIpAddresses"]["PublicIpAddresse"];
-		for (auto allCommonBandwidthPackagesNodePublicIpAddressesPublicIpAddresse : allPublicIpAddressesNode)
+		if(!valueCommonBandwidthPackagesCommonBandwidthPackage["ServiceManaged"].isNull())
+			commonBandwidthPackagesObject.serviceManaged = std::stoi(valueCommonBandwidthPackagesCommonBandwidthPackage["ServiceManaged"].asString());
+		auto allPublicIpAddressesNode = valueCommonBandwidthPackagesCommonBandwidthPackage["PublicIpAddresses"]["PublicIpAddresse"];
+		for (auto valueCommonBandwidthPackagesCommonBandwidthPackagePublicIpAddressesPublicIpAddresse : allPublicIpAddressesNode)
 		{
 			CommonBandwidthPackage::PublicIpAddresse publicIpAddressesObject;
-			if(!allCommonBandwidthPackagesNodePublicIpAddressesPublicIpAddresse["AllocationId"].isNull())
-				publicIpAddressesObject.allocationId = allCommonBandwidthPackagesNodePublicIpAddressesPublicIpAddresse["AllocationId"].asString();
-			if(!allCommonBandwidthPackagesNodePublicIpAddressesPublicIpAddresse["IpAddress"].isNull())
-				publicIpAddressesObject.ipAddress = allCommonBandwidthPackagesNodePublicIpAddressesPublicIpAddresse["IpAddress"].asString();
+			if(!valueCommonBandwidthPackagesCommonBandwidthPackagePublicIpAddressesPublicIpAddresse["AllocationId"].isNull())
+				publicIpAddressesObject.allocationId = valueCommonBandwidthPackagesCommonBandwidthPackagePublicIpAddressesPublicIpAddresse["AllocationId"].asString();
+			if(!valueCommonBandwidthPackagesCommonBandwidthPackagePublicIpAddressesPublicIpAddresse["IpAddress"].isNull())
+				publicIpAddressesObject.ipAddress = valueCommonBandwidthPackagesCommonBandwidthPackagePublicIpAddressesPublicIpAddresse["IpAddress"].asString();
+			if(!valueCommonBandwidthPackagesCommonBandwidthPackagePublicIpAddressesPublicIpAddresse["BandwidthPackageIpRelationStatus"].isNull())
+				publicIpAddressesObject.bandwidthPackageIpRelationStatus = valueCommonBandwidthPackagesCommonBandwidthPackagePublicIpAddressesPublicIpAddresse["BandwidthPackageIpRelationStatus"].asString();
 			commonBandwidthPackagesObject.publicIpAddresses.push_back(publicIpAddressesObject);
 		}
 		commonBandwidthPackages_.push_back(commonBandwidthPackagesObject);

vpc/src/model/DescribeCustomerGatewayResult.cc

@@ -49,6 +49,8 @@ void DescribeCustomerGatewayResult::parse(const std::string &payload)
 		description_ = value["Description"].asString();
 	if(!value["CreateTime"].isNull())
 		createTime_ = std::stol(value["CreateTime"].asString());
+	if(!value["Asn"].isNull())
+		asn_ = std::stoi(value["Asn"].asString());
 
 }
 
@@ -72,6 +74,11 @@ std::string DescribeCustomerGatewayResult::getIpAddress()const
 	return ipAddress_;
 }
 
+int DescribeCustomerGatewayResult::getAsn()const
+{
+	return asn_;
+}
+
 std::string DescribeCustomerGatewayResult::getName()const
 {
 	return name_;

vpc/src/model/DescribeCustomerGatewaysResult.cc

@@ -53,6 +53,8 @@ void DescribeCustomerGatewaysResult::parse(const std::string &payload)
 			customerGatewaysObject.description = valueCustomerGatewaysCustomerGateway["Description"].asString();
 		if(!valueCustomerGatewaysCustomerGateway["CreateTime"].isNull())
 			customerGatewaysObject.createTime = std::stol(valueCustomerGatewaysCustomerGateway["CreateTime"].asString());
+		if(!valueCustomerGatewaysCustomerGateway["Asn"].isNull())
+			customerGatewaysObject.asn = std::stoi(valueCustomerGatewaysCustomerGateway["Asn"].asString());
 		customerGateways_.push_back(customerGatewaysObject);
 	}
 	if(!value["TotalCount"].isNull())

vpc/src/model/DescribeEipAddressesRequest.cc

@@ -197,6 +197,17 @@ void DescribeEipAddressesRequest::setSegmentInstanceId(const std::string& segmen
 	setParameter("SegmentInstanceId", segmentInstanceId);
 }
 
+bool DescribeEipAddressesRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void DescribeEipAddressesRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
 std::string DescribeEipAddressesRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;

vpc/src/model/DescribeEipAddressesResult.cc

@@ -105,22 +105,28 @@ void DescribeEipAddressesResult::parse(const std::string &payload)
 			eipAddressesObject.secondLimited = valueEipAddressesEipAddress["SecondLimited"].asString() == "true";
 		if(!valueEipAddressesEipAddress["SegmentInstanceId"].isNull())
 			eipAddressesObject.segmentInstanceId = valueEipAddressesEipAddress["SegmentInstanceId"].asString();
-		auto allOperationLocksNode = allEipAddressesNode["OperationLocks"]["LockReason"];
-		for (auto allEipAddressesNodeOperationLocksLockReason : allOperationLocksNode)
+		if(!valueEipAddressesEipAddress["Netmode"].isNull())
+			eipAddressesObject.netmode = valueEipAddressesEipAddress["Netmode"].asString();
+		if(!valueEipAddressesEipAddress["ServiceManaged"].isNull())
+			eipAddressesObject.serviceManaged = std::stoi(valueEipAddressesEipAddress["ServiceManaged"].asString());
+		if(!valueEipAddressesEipAddress["BusinessStatus"].isNull())
+			eipAddressesObject.businessStatus = valueEipAddressesEipAddress["BusinessStatus"].asString();
+		auto allOperationLocksNode = valueEipAddressesEipAddress["OperationLocks"]["LockReason"];
+		for (auto valueEipAddressesEipAddressOperationLocksLockReason : allOperationLocksNode)
 		{
 			EipAddress::LockReason operationLocksObject;
-			if(!allEipAddressesNodeOperationLocksLockReason["LockReason"].isNull())
-				operationLocksObject.lockReason = allEipAddressesNodeOperationLocksLockReason["LockReason"].asString();
+			if(!valueEipAddressesEipAddressOperationLocksLockReason["LockReason"].isNull())
+				operationLocksObject.lockReason = valueEipAddressesEipAddressOperationLocksLockReason["LockReason"].asString();
 			eipAddressesObject.operationLocks.push_back(operationLocksObject);
 		}
-		auto allTagsNode = allEipAddressesNode["Tags"]["Tag"];
-		for (auto allEipAddressesNodeTagsTag : allTagsNode)
+		auto allTagsNode = valueEipAddressesEipAddress["Tags"]["Tag"];
+		for (auto valueEipAddressesEipAddressTagsTag : allTagsNode)
 		{
 			EipAddress::Tag tagsObject;
-			if(!allEipAddressesNodeTagsTag["Key"].isNull())
-				tagsObject.key = allEipAddressesNodeTagsTag["Key"].asString();
-			if(!allEipAddressesNodeTagsTag["Value"].isNull())
-				tagsObject.value = allEipAddressesNodeTagsTag["Value"].asString();
+			if(!valueEipAddressesEipAddressTagsTag["Key"].isNull())
+				tagsObject.key = valueEipAddressesEipAddressTagsTag["Key"].asString();
+			if(!valueEipAddressesEipAddressTagsTag["Value"].isNull())
+				tagsObject.value = valueEipAddressesEipAddressTagsTag["Value"].asString();
 			eipAddressesObject.tags.push_back(tagsObject);
 		}
 		auto allAvailableRegions = value["AvailableRegions"]["AvailableRegion"];

vpc/src/model/DescribeExpressCloudConnectionsResult.cc

@@ -115,16 +115,16 @@ void DescribeExpressCloudConnectionsResult::parse(const std::string &payload)
 			expressCloudConnectionSetObject.ceIp = valueExpressCloudConnectionSetExpressCloudConnectionType["CeIp"].asString();
 		if(!valueExpressCloudConnectionSetExpressCloudConnectionType["ConstructionPeriod"].isNull())
 			expressCloudConnectionSetObject.constructionPeriod = valueExpressCloudConnectionSetExpressCloudConnectionType["ConstructionPeriod"].asString();
-		auto allVirtualBorderRouterModelsNode = allExpressCloudConnectionSetNode["VirtualBorderRouterModels"]["VirtualBorderRouterModel"];
-		for (auto allExpressCloudConnectionSetNodeVirtualBorderRouterModelsVirtualBorderRouterModel : allVirtualBorderRouterModelsNode)
+		auto allVirtualBorderRouterModelsNode = valueExpressCloudConnectionSetExpressCloudConnectionType["VirtualBorderRouterModels"]["VirtualBorderRouterModel"];
+		for (auto valueExpressCloudConnectionSetExpressCloudConnectionTypeVirtualBorderRouterModelsVirtualBorderRouterModel : allVirtualBorderRouterModelsNode)
 		{
 			ExpressCloudConnectionType::VirtualBorderRouterModel virtualBorderRouterModelsObject;
-			if(!allExpressCloudConnectionSetNodeVirtualBorderRouterModelsVirtualBorderRouterModel["InstanceId"].isNull())
-				virtualBorderRouterModelsObject.instanceId = allExpressCloudConnectionSetNodeVirtualBorderRouterModelsVirtualBorderRouterModel["InstanceId"].asString();
-			if(!allExpressCloudConnectionSetNodeVirtualBorderRouterModelsVirtualBorderRouterModel["AccessPointId"].isNull())
-				virtualBorderRouterModelsObject.accessPointId = allExpressCloudConnectionSetNodeVirtualBorderRouterModelsVirtualBorderRouterModel["AccessPointId"].asString();
-			if(!allExpressCloudConnectionSetNodeVirtualBorderRouterModelsVirtualBorderRouterModel["PhysicalConnectionId"].isNull())
-				virtualBorderRouterModelsObject.physicalConnectionId = allExpressCloudConnectionSetNodeVirtualBorderRouterModelsVirtualBorderRouterModel["PhysicalConnectionId"].asString();
+			if(!valueExpressCloudConnectionSetExpressCloudConnectionTypeVirtualBorderRouterModelsVirtualBorderRouterModel["InstanceId"].isNull())
+				virtualBorderRouterModelsObject.instanceId = valueExpressCloudConnectionSetExpressCloudConnectionTypeVirtualBorderRouterModelsVirtualBorderRouterModel["InstanceId"].asString();
+			if(!valueExpressCloudConnectionSetExpressCloudConnectionTypeVirtualBorderRouterModelsVirtualBorderRouterModel["AccessPointId"].isNull())
+				virtualBorderRouterModelsObject.accessPointId = valueExpressCloudConnectionSetExpressCloudConnectionTypeVirtualBorderRouterModelsVirtualBorderRouterModel["AccessPointId"].asString();
+			if(!valueExpressCloudConnectionSetExpressCloudConnectionTypeVirtualBorderRouterModelsVirtualBorderRouterModel["PhysicalConnectionId"].isNull())
+				virtualBorderRouterModelsObject.physicalConnectionId = valueExpressCloudConnectionSetExpressCloudConnectionTypeVirtualBorderRouterModelsVirtualBorderRouterModel["PhysicalConnectionId"].asString();
 			expressCloudConnectionSetObject.virtualBorderRouterModels.push_back(virtualBorderRouterModelsObject);
 		}
 		expressCloudConnectionSet_.push_back(expressCloudConnectionSetObject);

vpc/src/model/DescribeFlowLogsRequest.cc

@@ -159,6 +159,17 @@ void DescribeFlowLogsRequest::setResourceType(const std::string& resourceType)
 	setParameter("ResourceType", resourceType);
 }
 
+std::string DescribeFlowLogsRequest::getVpcId()const
+{
+	return vpcId_;
+}
+
+void DescribeFlowLogsRequest::setVpcId(const std::string& vpcId)
+{
+	vpcId_ = vpcId;
+	setParameter("VpcId", vpcId);
+}
+
 std::string DescribeFlowLogsRequest::getTrafficType()const
 {
 	return trafficType_;

vpc/src/model/DescribeGlobalAccelerationInstancesResult.cc

@@ -81,36 +81,36 @@ void DescribeGlobalAccelerationInstancesResult::parse(const std::string &payload
 			globalAccelerationInstancesObject.reservationActiveTime = valueGlobalAccelerationInstancesGlobalAccelerationInstance["ReservationActiveTime"].asString();
 		if(!valueGlobalAccelerationInstancesGlobalAccelerationInstance["ReservationOrderType"].isNull())
 			globalAccelerationInstancesObject.reservationOrderType = valueGlobalAccelerationInstancesGlobalAccelerationInstance["ReservationOrderType"].asString();
-		auto allOperationLocksNode = allGlobalAccelerationInstancesNode["OperationLocks"]["LockReason"];
-		for (auto allGlobalAccelerationInstancesNodeOperationLocksLockReason : allOperationLocksNode)
+		auto allOperationLocksNode = valueGlobalAccelerationInstancesGlobalAccelerationInstance["OperationLocks"]["LockReason"];
+		for (auto valueGlobalAccelerationInstancesGlobalAccelerationInstanceOperationLocksLockReason : allOperationLocksNode)
 		{
 			GlobalAccelerationInstance::LockReason operationLocksObject;
-			if(!allGlobalAccelerationInstancesNodeOperationLocksLockReason["LockReason"].isNull())
-				operationLocksObject.lockReason = allGlobalAccelerationInstancesNodeOperationLocksLockReason["LockReason"].asString();
+			if(!valueGlobalAccelerationInstancesGlobalAccelerationInstanceOperationLocksLockReason["LockReason"].isNull())
+				operationLocksObject.lockReason = valueGlobalAccelerationInstancesGlobalAccelerationInstanceOperationLocksLockReason["LockReason"].asString();
 			globalAccelerationInstancesObject.operationLocks.push_back(operationLocksObject);
 		}
-		auto allBackendServersNode = allGlobalAccelerationInstancesNode["BackendServers"]["BackendServer"];
-		for (auto allGlobalAccelerationInstancesNodeBackendServersBackendServer : allBackendServersNode)
+		auto allBackendServersNode = valueGlobalAccelerationInstancesGlobalAccelerationInstance["BackendServers"]["BackendServer"];
+		for (auto valueGlobalAccelerationInstancesGlobalAccelerationInstanceBackendServersBackendServer : allBackendServersNode)
 		{
 			GlobalAccelerationInstance::BackendServer backendServersObject;
-			if(!allGlobalAccelerationInstancesNodeBackendServersBackendServer["RegionId"].isNull())
-				backendServersObject.regionId = allGlobalAccelerationInstancesNodeBackendServersBackendServer["RegionId"].asString();
-			if(!allGlobalAccelerationInstancesNodeBackendServersBackendServer["ServerId"].isNull())
-				backendServersObject.serverId = allGlobalAccelerationInstancesNodeBackendServersBackendServer["ServerId"].asString();
-			if(!allGlobalAccelerationInstancesNodeBackendServersBackendServer["ServerIpAddress"].isNull())
-				backendServersObject.serverIpAddress = allGlobalAccelerationInstancesNodeBackendServersBackendServer["ServerIpAddress"].asString();
-			if(!allGlobalAccelerationInstancesNodeBackendServersBackendServer["ServerType"].isNull())
-				backendServersObject.serverType = allGlobalAccelerationInstancesNodeBackendServersBackendServer["ServerType"].asString();
+			if(!valueGlobalAccelerationInstancesGlobalAccelerationInstanceBackendServersBackendServer["RegionId"].isNull())
+				backendServersObject.regionId = valueGlobalAccelerationInstancesGlobalAccelerationInstanceBackendServersBackendServer["RegionId"].asString();
+			if(!valueGlobalAccelerationInstancesGlobalAccelerationInstanceBackendServersBackendServer["ServerId"].isNull())
+				backendServersObject.serverId = valueGlobalAccelerationInstancesGlobalAccelerationInstanceBackendServersBackendServer["ServerId"].asString();
+			if(!valueGlobalAccelerationInstancesGlobalAccelerationInstanceBackendServersBackendServer["ServerIpAddress"].isNull())
+				backendServersObject.serverIpAddress = valueGlobalAccelerationInstancesGlobalAccelerationInstanceBackendServersBackendServer["ServerIpAddress"].asString();
+			if(!valueGlobalAccelerationInstancesGlobalAccelerationInstanceBackendServersBackendServer["ServerType"].isNull())
+				backendServersObject.serverType = valueGlobalAccelerationInstancesGlobalAccelerationInstanceBackendServersBackendServer["ServerType"].asString();
 			globalAccelerationInstancesObject.backendServers.push_back(backendServersObject);
 		}
-		auto allPublicIpAddressesNode = allGlobalAccelerationInstancesNode["PublicIpAddresses"]["PublicIpAddress"];
-		for (auto allGlobalAccelerationInstancesNodePublicIpAddressesPublicIpAddress : allPublicIpAddressesNode)
+		auto allPublicIpAddressesNode = valueGlobalAccelerationInstancesGlobalAccelerationInstance["PublicIpAddresses"]["PublicIpAddress"];
+		for (auto valueGlobalAccelerationInstancesGlobalAccelerationInstancePublicIpAddressesPublicIpAddress : allPublicIpAddressesNode)
 		{
 			GlobalAccelerationInstance::PublicIpAddress publicIpAddressesObject;
-			if(!allGlobalAccelerationInstancesNodePublicIpAddressesPublicIpAddress["AllocationId"].isNull())
-				publicIpAddressesObject.allocationId = allGlobalAccelerationInstancesNodePublicIpAddressesPublicIpAddress["AllocationId"].asString();
-			if(!allGlobalAccelerationInstancesNodePublicIpAddressesPublicIpAddress["IpAddress"].isNull())
-				publicIpAddressesObject.ipAddress = allGlobalAccelerationInstancesNodePublicIpAddressesPublicIpAddress["IpAddress"].asString();
+			if(!valueGlobalAccelerationInstancesGlobalAccelerationInstancePublicIpAddressesPublicIpAddress["AllocationId"].isNull())
+				publicIpAddressesObject.allocationId = valueGlobalAccelerationInstancesGlobalAccelerationInstancePublicIpAddressesPublicIpAddress["AllocationId"].asString();
+			if(!valueGlobalAccelerationInstancesGlobalAccelerationInstancePublicIpAddressesPublicIpAddress["IpAddress"].isNull())
+				publicIpAddressesObject.ipAddress = valueGlobalAccelerationInstancesGlobalAccelerationInstancePublicIpAddressesPublicIpAddress["IpAddress"].asString();
 			globalAccelerationInstancesObject.publicIpAddresses.push_back(publicIpAddressesObject);
 		}
 		globalAccelerationInstances_.push_back(globalAccelerationInstancesObject);

vpc/src/model/DescribeHaVipsResult.cc

@@ -65,6 +65,8 @@ void DescribeHaVipsResult::parse(const std::string &payload)
 			haVipsObject.chargeType = valueHaVipsHaVip["ChargeType"].asString();
 		if(!valueHaVipsHaVip["CreateTime"].isNull())
 			haVipsObject.createTime = valueHaVipsHaVip["CreateTime"].asString();
+		if(!valueHaVipsHaVip["AssociatedInstanceType"].isNull())
+			haVipsObject.associatedInstanceType = valueHaVipsHaVip["AssociatedInstanceType"].asString();
 		auto allAssociatedInstances = value["AssociatedInstances"]["associatedInstance"];
 		for (auto value : allAssociatedInstances)
 			haVipsObject.associatedInstances.push_back(value.asString());

vpc/src/model/DescribeInstanceAutoRenewAttributeRequest.cc

@@ -0,0 +1,128 @@
+/*
+ * 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/vpc/model/DescribeInstanceAutoRenewAttributeRequest.h>
+
+using AlibabaCloud::Vpc::Model::DescribeInstanceAutoRenewAttributeRequest;
+
+DescribeInstanceAutoRenewAttributeRequest::DescribeInstanceAutoRenewAttributeRequest() :
+	RpcServiceRequest("vpc", "2016-04-28", "DescribeInstanceAutoRenewAttribute")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeInstanceAutoRenewAttributeRequest::~DescribeInstanceAutoRenewAttributeRequest()
+{}
+
+long DescribeInstanceAutoRenewAttributeRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeInstanceAutoRenewAttributeRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+int DescribeInstanceAutoRenewAttributeRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeInstanceAutoRenewAttributeRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DescribeInstanceAutoRenewAttributeRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeInstanceAutoRenewAttributeRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DescribeInstanceAutoRenewAttributeRequest::getRenewalStatus()const
+{
+	return renewalStatus_;
+}
+
+void DescribeInstanceAutoRenewAttributeRequest::setRenewalStatus(const std::string& renewalStatus)
+{
+	renewalStatus_ = renewalStatus;
+	setParameter("RenewalStatus", renewalStatus);
+}
+
+int DescribeInstanceAutoRenewAttributeRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeInstanceAutoRenewAttributeRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string DescribeInstanceAutoRenewAttributeRequest::getInstanceType()const
+{
+	return instanceType_;
+}
+
+void DescribeInstanceAutoRenewAttributeRequest::setInstanceType(const std::string& instanceType)
+{
+	instanceType_ = instanceType;
+	setParameter("InstanceType", instanceType);
+}
+
+std::string DescribeInstanceAutoRenewAttributeRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeInstanceAutoRenewAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+long DescribeInstanceAutoRenewAttributeRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeInstanceAutoRenewAttributeRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeInstanceAutoRenewAttributeRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void DescribeInstanceAutoRenewAttributeRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+

vpc/src/model/DescribeInstanceAutoRenewAttributeResult.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/vpc/model/DescribeInstanceAutoRenewAttributeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+DescribeInstanceAutoRenewAttributeResult::DescribeInstanceAutoRenewAttributeResult() :
+	ServiceResult()
+{}
+
+DescribeInstanceAutoRenewAttributeResult::DescribeInstanceAutoRenewAttributeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeInstanceAutoRenewAttributeResult::~DescribeInstanceAutoRenewAttributeResult()
+{}
+
+void DescribeInstanceAutoRenewAttributeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allInstanceRenewAttributesNode = value["InstanceRenewAttributes"]["InstanceRenewAttribute"];
+	for (auto valueInstanceRenewAttributesInstanceRenewAttribute : allInstanceRenewAttributesNode)
+	{
+		InstanceRenewAttribute instanceRenewAttributesObject;
+		if(!valueInstanceRenewAttributesInstanceRenewAttribute["InstanceId"].isNull())
+			instanceRenewAttributesObject.instanceId = valueInstanceRenewAttributesInstanceRenewAttribute["InstanceId"].asString();
+		if(!valueInstanceRenewAttributesInstanceRenewAttribute["RenewalStatus"].isNull())
+			instanceRenewAttributesObject.renewalStatus = valueInstanceRenewAttributesInstanceRenewAttribute["RenewalStatus"].asString();
+		if(!valueInstanceRenewAttributesInstanceRenewAttribute["Duration"].isNull())
+			instanceRenewAttributesObject.duration = std::stoi(valueInstanceRenewAttributesInstanceRenewAttribute["Duration"].asString());
+		if(!valueInstanceRenewAttributesInstanceRenewAttribute["PricingCycle"].isNull())
+			instanceRenewAttributesObject.pricingCycle = valueInstanceRenewAttributesInstanceRenewAttribute["PricingCycle"].asString();
+		instanceRenewAttributes_.push_back(instanceRenewAttributesObject);
+	}
+	if(!value["TotalCount"].isNull())
+		totalCount_ = value["TotalCount"].asString();
+	if(!value["PageSize"].isNull())
+		pageSize_ = value["PageSize"].asString();
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = value["PageNumber"].asString();
+
+}
+
+std::string DescribeInstanceAutoRenewAttributeResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::vector<DescribeInstanceAutoRenewAttributeResult::InstanceRenewAttribute> DescribeInstanceAutoRenewAttributeResult::getInstanceRenewAttributes()const
+{
+	return instanceRenewAttributes_;
+}
+
+std::string DescribeInstanceAutoRenewAttributeResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+std::string DescribeInstanceAutoRenewAttributeResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

vpc/src/model/DescribeIpv6AddressesResult.cc

@@ -67,6 +67,8 @@ void DescribeIpv6AddressesResult::parse(const std::string &payload)
 			ipv6AddressesObject.realBandwidth = std::stoi(valueIpv6AddressesIpv6Address["RealBandwidth"].asString());
 		if(!valueIpv6AddressesIpv6Address["AllocationTime"].isNull())
 			ipv6AddressesObject.allocationTime = valueIpv6AddressesIpv6Address["AllocationTime"].asString();
+		if(!valueIpv6AddressesIpv6Address["Ipv6Isp"].isNull())
+			ipv6AddressesObject.ipv6Isp = valueIpv6AddressesIpv6Address["Ipv6Isp"].asString();
 		auto ipv6InternetBandwidthNode = value["Ipv6InternetBandwidth"];
 		if(!ipv6InternetBandwidthNode["Bandwidth"].isNull())
 			ipv6AddressesObject.ipv6InternetBandwidth.bandwidth = std::stoi(ipv6InternetBandwidthNode["Bandwidth"].asString());

vpc/src/model/DescribeNatGatewaysRequest.cc

@@ -115,6 +115,22 @@ void DescribeNatGatewaysRequest::setNatGatewayId(const std::string& natGatewayId
 	setParameter("NatGatewayId", natGatewayId);
 }
 
+std::vector<DescribeNatGatewaysRequest::Tag> DescribeNatGatewaysRequest::getTag()const
+{
+	return tag_;
+}
+
+void DescribeNatGatewaysRequest::setTag(const std::vector<Tag>& tag)
+{
+	tag_ = tag;
+	for(int dep1 = 0; dep1!= tag.size(); dep1++) {
+		auto tagObj = tag.at(dep1);
+		std::string tagObjStr = "Tag." + std::to_string(dep1 + 1);
+		setParameter(tagObjStr + ".Value", tagObj.value);
+		setParameter(tagObjStr + ".Key", tagObj.key);
+	}
+}
+
 std::string DescribeNatGatewaysRequest::getInstanceChargeType()const
 {
 	return instanceChargeType_;
@@ -126,6 +142,17 @@ void DescribeNatGatewaysRequest::setInstanceChargeType(const std::string& instan
 	setParameter("InstanceChargeType", instanceChargeType);
 }
 
+bool DescribeNatGatewaysRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void DescribeNatGatewaysRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
 std::string DescribeNatGatewaysRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -181,3 +208,14 @@ void DescribeNatGatewaysRequest::setName(const std::string& name)
 	setParameter("Name", name);
 }
 
+std::string DescribeNatGatewaysRequest::getStatus()const
+{
+	return status_;
+}
+
+void DescribeNatGatewaysRequest::setStatus(const std::string& status)
+{
+	status_ = status;
+	setParameter("Status", status);
+}
+

vpc/src/model/DescribeNatGatewaysResult.cc

@@ -75,25 +75,29 @@ void DescribeNatGatewaysResult::parse(const std::string &payload)
 			natGatewaysObject.resourceGroupId = valueNatGatewaysNatGateway["ResourceGroupId"].asString();
 		if(!valueNatGatewaysNatGateway["DeletionProtection"].isNull())
 			natGatewaysObject.deletionProtection = valueNatGatewaysNatGateway["DeletionProtection"].asString() == "true";
-		auto allIpListsNode = allNatGatewaysNode["IpLists"]["IpList"];
-		for (auto allNatGatewaysNodeIpListsIpList : allIpListsNode)
+		if(!valueNatGatewaysNatGateway["EcsMetricEnabled"].isNull())
+			natGatewaysObject.ecsMetricEnabled = valueNatGatewaysNatGateway["EcsMetricEnabled"].asString() == "true";
+		auto allIpListsNode = valueNatGatewaysNatGateway["IpLists"]["IpList"];
+		for (auto valueNatGatewaysNatGatewayIpListsIpList : allIpListsNode)
 		{
 			NatGateway::IpList ipListsObject;
-			if(!allNatGatewaysNodeIpListsIpList["AllocationId"].isNull())
-				ipListsObject.allocationId = allNatGatewaysNodeIpListsIpList["AllocationId"].asString();
-			if(!allNatGatewaysNodeIpListsIpList["IpAddress"].isNull())
-				ipListsObject.ipAddress = allNatGatewaysNodeIpListsIpList["IpAddress"].asString();
-			if(!allNatGatewaysNodeIpListsIpList["UsingStatus"].isNull())
-				ipListsObject.usingStatus = allNatGatewaysNodeIpListsIpList["UsingStatus"].asString();
-			if(!allNatGatewaysNodeIpListsIpList["ApAccessEnabled"].isNull())
-				ipListsObject.apAccessEnabled = allNatGatewaysNodeIpListsIpList["ApAccessEnabled"].asString() == "true";
-			if(!allNatGatewaysNodeIpListsIpList["SnatEntryEnabled"].isNull())
-				ipListsObject.snatEntryEnabled = allNatGatewaysNodeIpListsIpList["SnatEntryEnabled"].asString() == "true";
+			if(!valueNatGatewaysNatGatewayIpListsIpList["AllocationId"].isNull())
+				ipListsObject.allocationId = valueNatGatewaysNatGatewayIpListsIpList["AllocationId"].asString();
+			if(!valueNatGatewaysNatGatewayIpListsIpList["IpAddress"].isNull())
+				ipListsObject.ipAddress = valueNatGatewaysNatGatewayIpListsIpList["IpAddress"].asString();
+			if(!valueNatGatewaysNatGatewayIpListsIpList["UsingStatus"].isNull())
+				ipListsObject.usingStatus = valueNatGatewaysNatGatewayIpListsIpList["UsingStatus"].asString();
+			if(!valueNatGatewaysNatGatewayIpListsIpList["ApAccessEnabled"].isNull())
+				ipListsObject.apAccessEnabled = valueNatGatewaysNatGatewayIpListsIpList["ApAccessEnabled"].asString() == "true";
+			if(!valueNatGatewaysNatGatewayIpListsIpList["SnatEntryEnabled"].isNull())
+				ipListsObject.snatEntryEnabled = valueNatGatewaysNatGatewayIpListsIpList["SnatEntryEnabled"].asString() == "true";
+			if(!valueNatGatewaysNatGatewayIpListsIpList["PrivateIpAddress"].isNull())
+				ipListsObject.privateIpAddress = valueNatGatewaysNatGatewayIpListsIpList["PrivateIpAddress"].asString();
 			natGatewaysObject.ipLists.push_back(ipListsObject);
 		}
 		auto natGatewayPrivateInfoNode = value["NatGatewayPrivateInfo"];
 		if(!natGatewayPrivateInfoNode["EniInstanceId"].isNull())
-			natGatewaysObject.natGatewayPrivateInfo.eniInstanceId = std::stoi(natGatewayPrivateInfoNode["EniInstanceId"].asString());
+			natGatewaysObject.natGatewayPrivateInfo.eniInstanceId = natGatewayPrivateInfoNode["EniInstanceId"].asString();
 		if(!natGatewayPrivateInfoNode["PrivateIpAddress"].isNull())
 			natGatewaysObject.natGatewayPrivateInfo.privateIpAddress = natGatewayPrivateInfoNode["PrivateIpAddress"].asString();
 		if(!natGatewayPrivateInfoNode["VswitchId"].isNull())
@@ -102,6 +106,8 @@ void DescribeNatGatewaysResult::parse(const std::string &payload)
 			natGatewaysObject.natGatewayPrivateInfo.izNo = natGatewayPrivateInfoNode["IzNo"].asString();
 		if(!natGatewayPrivateInfoNode["MaxBandwidth"].isNull())
 			natGatewaysObject.natGatewayPrivateInfo.maxBandwidth = std::stoi(natGatewayPrivateInfoNode["MaxBandwidth"].asString());
+		if(!natGatewayPrivateInfoNode["EniType"].isNull())
+			natGatewaysObject.natGatewayPrivateInfo.eniType = natGatewayPrivateInfoNode["EniType"].asString();
 		auto allForwardTableIds = value["ForwardTableIds"]["ForwardTableId"];
 		for (auto value : allForwardTableIds)
 			natGatewaysObject.forwardTableIds.push_back(value.asString());

vpc/src/model/DescribeNetworkAclAttributesResult.cc

@@ -54,6 +54,8 @@ void DescribeNetworkAclAttributesResult::parse(const std::string &payload)
 		networkAclAttribute_.creationTime = networkAclAttributeNode["CreationTime"].asString();
 	if(!networkAclAttributeNode["Status"].isNull())
 		networkAclAttribute_.status = networkAclAttributeNode["Status"].asString();
+	if(!networkAclAttributeNode["OwnerId"].isNull())
+		networkAclAttribute_.ownerId = std::stol(networkAclAttributeNode["OwnerId"].asString());
 	auto allIngressAclEntriesNode = networkAclAttributeNode["IngressAclEntries"]["IngressAclEntry"];
 	for (auto networkAclAttributeNodeIngressAclEntriesIngressAclEntry : allIngressAclEntriesNode)
 	{

vpc/src/model/DescribeNetworkAclsResult.cc

@@ -57,60 +57,62 @@ void DescribeNetworkAclsResult::parse(const std::string &payload)
 			networkAclsObject.creationTime = valueNetworkAclsNetworkAcl["CreationTime"].asString();
 		if(!valueNetworkAclsNetworkAcl["Status"].isNull())
 			networkAclsObject.status = valueNetworkAclsNetworkAcl["Status"].asString();
-		auto allIngressAclEntriesNode = allNetworkAclsNode["IngressAclEntries"]["IngressAclEntry"];
-		for (auto allNetworkAclsNodeIngressAclEntriesIngressAclEntry : allIngressAclEntriesNode)
+		if(!valueNetworkAclsNetworkAcl["OwnerId"].isNull())
+			networkAclsObject.ownerId = std::stol(valueNetworkAclsNetworkAcl["OwnerId"].asString());
+		auto allIngressAclEntriesNode = valueNetworkAclsNetworkAcl["IngressAclEntries"]["IngressAclEntry"];
+		for (auto valueNetworkAclsNetworkAclIngressAclEntriesIngressAclEntry : allIngressAclEntriesNode)
 		{
 			NetworkAcl::IngressAclEntry ingressAclEntriesObject;
-			if(!allNetworkAclsNodeIngressAclEntriesIngressAclEntry["NetworkAclEntryId"].isNull())
-				ingressAclEntriesObject.networkAclEntryId = allNetworkAclsNodeIngressAclEntriesIngressAclEntry["NetworkAclEntryId"].asString();
-			if(!allNetworkAclsNodeIngressAclEntriesIngressAclEntry["Policy"].isNull())
-				ingressAclEntriesObject.policy = allNetworkAclsNodeIngressAclEntriesIngressAclEntry["Policy"].asString();
-			if(!allNetworkAclsNodeIngressAclEntriesIngressAclEntry["Protocol"].isNull())
-				ingressAclEntriesObject.protocol = allNetworkAclsNodeIngressAclEntriesIngressAclEntry["Protocol"].asString();
-			if(!allNetworkAclsNodeIngressAclEntriesIngressAclEntry["SourceCidrIp"].isNull())
-				ingressAclEntriesObject.sourceCidrIp = allNetworkAclsNodeIngressAclEntriesIngressAclEntry["SourceCidrIp"].asString();
-			if(!allNetworkAclsNodeIngressAclEntriesIngressAclEntry["Port"].isNull())
-				ingressAclEntriesObject.port = allNetworkAclsNodeIngressAclEntriesIngressAclEntry["Port"].asString();
-			if(!allNetworkAclsNodeIngressAclEntriesIngressAclEntry["EntryType"].isNull())
-				ingressAclEntriesObject.entryType = allNetworkAclsNodeIngressAclEntriesIngressAclEntry["EntryType"].asString();
-			if(!allNetworkAclsNodeIngressAclEntriesIngressAclEntry["NetworkAclEntryName"].isNull())
-				ingressAclEntriesObject.networkAclEntryName = allNetworkAclsNodeIngressAclEntriesIngressAclEntry["NetworkAclEntryName"].asString();
-			if(!allNetworkAclsNodeIngressAclEntriesIngressAclEntry["Description"].isNull())
-				ingressAclEntriesObject.description = allNetworkAclsNodeIngressAclEntriesIngressAclEntry["Description"].asString();
+			if(!valueNetworkAclsNetworkAclIngressAclEntriesIngressAclEntry["NetworkAclEntryId"].isNull())
+				ingressAclEntriesObject.networkAclEntryId = valueNetworkAclsNetworkAclIngressAclEntriesIngressAclEntry["NetworkAclEntryId"].asString();
+			if(!valueNetworkAclsNetworkAclIngressAclEntriesIngressAclEntry["Policy"].isNull())
+				ingressAclEntriesObject.policy = valueNetworkAclsNetworkAclIngressAclEntriesIngressAclEntry["Policy"].asString();
+			if(!valueNetworkAclsNetworkAclIngressAclEntriesIngressAclEntry["Protocol"].isNull())
+				ingressAclEntriesObject.protocol = valueNetworkAclsNetworkAclIngressAclEntriesIngressAclEntry["Protocol"].asString();
+			if(!valueNetworkAclsNetworkAclIngressAclEntriesIngressAclEntry["SourceCidrIp"].isNull())
+				ingressAclEntriesObject.sourceCidrIp = valueNetworkAclsNetworkAclIngressAclEntriesIngressAclEntry["SourceCidrIp"].asString();
+			if(!valueNetworkAclsNetworkAclIngressAclEntriesIngressAclEntry["Port"].isNull())
+				ingressAclEntriesObject.port = valueNetworkAclsNetworkAclIngressAclEntriesIngressAclEntry["Port"].asString();
+			if(!valueNetworkAclsNetworkAclIngressAclEntriesIngressAclEntry["EntryType"].isNull())
+				ingressAclEntriesObject.entryType = valueNetworkAclsNetworkAclIngressAclEntriesIngressAclEntry["EntryType"].asString();
+			if(!valueNetworkAclsNetworkAclIngressAclEntriesIngressAclEntry["NetworkAclEntryName"].isNull())
+				ingressAclEntriesObject.networkAclEntryName = valueNetworkAclsNetworkAclIngressAclEntriesIngressAclEntry["NetworkAclEntryName"].asString();
+			if(!valueNetworkAclsNetworkAclIngressAclEntriesIngressAclEntry["Description"].isNull())
+				ingressAclEntriesObject.description = valueNetworkAclsNetworkAclIngressAclEntriesIngressAclEntry["Description"].asString();
 			networkAclsObject.ingressAclEntries.push_back(ingressAclEntriesObject);
 		}
-		auto allEgressAclEntriesNode = allNetworkAclsNode["EgressAclEntries"]["EgressAclEntry"];
-		for (auto allNetworkAclsNodeEgressAclEntriesEgressAclEntry : allEgressAclEntriesNode)
+		auto allEgressAclEntriesNode = valueNetworkAclsNetworkAcl["EgressAclEntries"]["EgressAclEntry"];
+		for (auto valueNetworkAclsNetworkAclEgressAclEntriesEgressAclEntry : allEgressAclEntriesNode)
 		{
 			NetworkAcl::EgressAclEntry egressAclEntriesObject;
-			if(!allNetworkAclsNodeEgressAclEntriesEgressAclEntry["NetworkAclEntryId"].isNull())
-				egressAclEntriesObject.networkAclEntryId = allNetworkAclsNodeEgressAclEntriesEgressAclEntry["NetworkAclEntryId"].asString();
-			if(!allNetworkAclsNodeEgressAclEntriesEgressAclEntry["Policy"].isNull())
-				egressAclEntriesObject.policy = allNetworkAclsNodeEgressAclEntriesEgressAclEntry["Policy"].asString();
-			if(!allNetworkAclsNodeEgressAclEntriesEgressAclEntry["Protocol"].isNull())
-				egressAclEntriesObject.protocol = allNetworkAclsNodeEgressAclEntriesEgressAclEntry["Protocol"].asString();
-			if(!allNetworkAclsNodeEgressAclEntriesEgressAclEntry["DestinationCidrIp"].isNull())
-				egressAclEntriesObject.destinationCidrIp = allNetworkAclsNodeEgressAclEntriesEgressAclEntry["DestinationCidrIp"].asString();
-			if(!allNetworkAclsNodeEgressAclEntriesEgressAclEntry["Port"].isNull())
-				egressAclEntriesObject.port = allNetworkAclsNodeEgressAclEntriesEgressAclEntry["Port"].asString();
-			if(!allNetworkAclsNodeEgressAclEntriesEgressAclEntry["EntryType"].isNull())
-				egressAclEntriesObject.entryType = allNetworkAclsNodeEgressAclEntriesEgressAclEntry["EntryType"].asString();
-			if(!allNetworkAclsNodeEgressAclEntriesEgressAclEntry["Description"].isNull())
-				egressAclEntriesObject.description = allNetworkAclsNodeEgressAclEntriesEgressAclEntry["Description"].asString();
-			if(!allNetworkAclsNodeEgressAclEntriesEgressAclEntry["NetworkAclEntryName"].isNull())
-				egressAclEntriesObject.networkAclEntryName = allNetworkAclsNodeEgressAclEntriesEgressAclEntry["NetworkAclEntryName"].asString();
+			if(!valueNetworkAclsNetworkAclEgressAclEntriesEgressAclEntry["NetworkAclEntryId"].isNull())
+				egressAclEntriesObject.networkAclEntryId = valueNetworkAclsNetworkAclEgressAclEntriesEgressAclEntry["NetworkAclEntryId"].asString();
+			if(!valueNetworkAclsNetworkAclEgressAclEntriesEgressAclEntry["Policy"].isNull())
+				egressAclEntriesObject.policy = valueNetworkAclsNetworkAclEgressAclEntriesEgressAclEntry["Policy"].asString();
+			if(!valueNetworkAclsNetworkAclEgressAclEntriesEgressAclEntry["Protocol"].isNull())
+				egressAclEntriesObject.protocol = valueNetworkAclsNetworkAclEgressAclEntriesEgressAclEntry["Protocol"].asString();
+			if(!valueNetworkAclsNetworkAclEgressAclEntriesEgressAclEntry["DestinationCidrIp"].isNull())
+				egressAclEntriesObject.destinationCidrIp = valueNetworkAclsNetworkAclEgressAclEntriesEgressAclEntry["DestinationCidrIp"].asString();
+			if(!valueNetworkAclsNetworkAclEgressAclEntriesEgressAclEntry["Port"].isNull())
+				egressAclEntriesObject.port = valueNetworkAclsNetworkAclEgressAclEntriesEgressAclEntry["Port"].asString();
+			if(!valueNetworkAclsNetworkAclEgressAclEntriesEgressAclEntry["EntryType"].isNull())
+				egressAclEntriesObject.entryType = valueNetworkAclsNetworkAclEgressAclEntriesEgressAclEntry["EntryType"].asString();
+			if(!valueNetworkAclsNetworkAclEgressAclEntriesEgressAclEntry["Description"].isNull())
+				egressAclEntriesObject.description = valueNetworkAclsNetworkAclEgressAclEntriesEgressAclEntry["Description"].asString();
+			if(!valueNetworkAclsNetworkAclEgressAclEntriesEgressAclEntry["NetworkAclEntryName"].isNull())
+				egressAclEntriesObject.networkAclEntryName = valueNetworkAclsNetworkAclEgressAclEntriesEgressAclEntry["NetworkAclEntryName"].asString();
 			networkAclsObject.egressAclEntries.push_back(egressAclEntriesObject);
 		}
-		auto allResourcesNode = allNetworkAclsNode["Resources"]["Resource"];
-		for (auto allNetworkAclsNodeResourcesResource : allResourcesNode)
+		auto allResourcesNode = valueNetworkAclsNetworkAcl["Resources"]["Resource"];
+		for (auto valueNetworkAclsNetworkAclResourcesResource : allResourcesNode)
 		{
 			NetworkAcl::Resource resourcesObject;
-			if(!allNetworkAclsNodeResourcesResource["ResourceId"].isNull())
-				resourcesObject.resourceId = allNetworkAclsNodeResourcesResource["ResourceId"].asString();
-			if(!allNetworkAclsNodeResourcesResource["ResourceType"].isNull())
-				resourcesObject.resourceType = allNetworkAclsNodeResourcesResource["ResourceType"].asString();
-			if(!allNetworkAclsNodeResourcesResource["Status"].isNull())
-				resourcesObject.status = allNetworkAclsNodeResourcesResource["Status"].asString();
+			if(!valueNetworkAclsNetworkAclResourcesResource["ResourceId"].isNull())
+				resourcesObject.resourceId = valueNetworkAclsNetworkAclResourcesResource["ResourceId"].asString();
+			if(!valueNetworkAclsNetworkAclResourcesResource["ResourceType"].isNull())
+				resourcesObject.resourceType = valueNetworkAclsNetworkAclResourcesResource["ResourceType"].asString();
+			if(!valueNetworkAclsNetworkAclResourcesResource["Status"].isNull())
+				resourcesObject.status = valueNetworkAclsNetworkAclResourcesResource["Status"].asString();
 			networkAclsObject.resources.push_back(resourcesObject);
 		}
 		networkAcls_.push_back(networkAclsObject);

vpc/src/model/DescribeRouteEntryListResult.cc

@@ -59,20 +59,20 @@ void DescribeRouteEntryListResult::parse(const std::string &payload)
 			routeEntrysObject.status = valueRouteEntrysRouteEntry["Status"].asString();
 		if(!valueRouteEntrysRouteEntry["IpVersion"].isNull())
 			routeEntrysObject.ipVersion = valueRouteEntrysRouteEntry["IpVersion"].asString();
-		auto allNextHopsNode = allRouteEntrysNode["NextHops"]["NextHop"];
-		for (auto allRouteEntrysNodeNextHopsNextHop : allNextHopsNode)
+		auto allNextHopsNode = valueRouteEntrysRouteEntry["NextHops"]["NextHop"];
+		for (auto valueRouteEntrysRouteEntryNextHopsNextHop : allNextHopsNode)
 		{
 			RouteEntry::NextHop nextHopsObject;
-			if(!allRouteEntrysNodeNextHopsNextHop["NextHopType"].isNull())
-				nextHopsObject.nextHopType = allRouteEntrysNodeNextHopsNextHop["NextHopType"].asString();
-			if(!allRouteEntrysNodeNextHopsNextHop["NextHopId"].isNull())
-				nextHopsObject.nextHopId = allRouteEntrysNodeNextHopsNextHop["NextHopId"].asString();
-			if(!allRouteEntrysNodeNextHopsNextHop["Enabled"].isNull())
-				nextHopsObject.enabled = std::stoi(allRouteEntrysNodeNextHopsNextHop["Enabled"].asString());
-			if(!allRouteEntrysNodeNextHopsNextHop["Weight"].isNull())
-				nextHopsObject.weight = std::stoi(allRouteEntrysNodeNextHopsNextHop["Weight"].asString());
-			if(!allRouteEntrysNodeNextHopsNextHop["NextHopRegionId"].isNull())
-				nextHopsObject.nextHopRegionId = allRouteEntrysNodeNextHopsNextHop["NextHopRegionId"].asString();
+			if(!valueRouteEntrysRouteEntryNextHopsNextHop["NextHopType"].isNull())
+				nextHopsObject.nextHopType = valueRouteEntrysRouteEntryNextHopsNextHop["NextHopType"].asString();
+			if(!valueRouteEntrysRouteEntryNextHopsNextHop["NextHopId"].isNull())
+				nextHopsObject.nextHopId = valueRouteEntrysRouteEntryNextHopsNextHop["NextHopId"].asString();
+			if(!valueRouteEntrysRouteEntryNextHopsNextHop["Enabled"].isNull())
+				nextHopsObject.enabled = std::stoi(valueRouteEntrysRouteEntryNextHopsNextHop["Enabled"].asString());
+			if(!valueRouteEntrysRouteEntryNextHopsNextHop["Weight"].isNull())
+				nextHopsObject.weight = std::stoi(valueRouteEntrysRouteEntryNextHopsNextHop["Weight"].asString());
+			if(!valueRouteEntrysRouteEntryNextHopsNextHop["NextHopRegionId"].isNull())
+				nextHopsObject.nextHopRegionId = valueRouteEntrysRouteEntryNextHopsNextHop["NextHopRegionId"].asString();
 			auto nextHopRelatedInfoNode = value["NextHopRelatedInfo"];
 			if(!nextHopRelatedInfoNode["InstanceType"].isNull())
 				nextHopsObject.nextHopRelatedInfo.instanceType = nextHopRelatedInfoNode["InstanceType"].asString();

vpc/src/model/DescribeRouteTableListResult.cc

@@ -63,14 +63,16 @@ void DescribeRouteTableListResult::parse(const std::string &payload)
 			routerTableListObject.creationTime = valueRouterTableListRouterTableListType["CreationTime"].asString();
 		if(!valueRouterTableListRouterTableListType["Status"].isNull())
 			routerTableListObject.status = valueRouterTableListRouterTableListType["Status"].asString();
-		auto allTagsNode = allRouterTableListNode["Tags"]["Tag"];
-		for (auto allRouterTableListNodeTagsTag : allTagsNode)
+		if(!valueRouterTableListRouterTableListType["OwnerId"].isNull())
+			routerTableListObject.ownerId = std::stol(valueRouterTableListRouterTableListType["OwnerId"].asString());
+		auto allTagsNode = valueRouterTableListRouterTableListType["Tags"]["Tag"];
+		for (auto valueRouterTableListRouterTableListTypeTagsTag : allTagsNode)
 		{
 			RouterTableListType::Tag tagsObject;
-			if(!allRouterTableListNodeTagsTag["Key"].isNull())
-				tagsObject.key = allRouterTableListNodeTagsTag["Key"].asString();
-			if(!allRouterTableListNodeTagsTag["Value"].isNull())
-				tagsObject.value = allRouterTableListNodeTagsTag["Value"].asString();
+			if(!valueRouterTableListRouterTableListTypeTagsTag["Key"].isNull())
+				tagsObject.key = valueRouterTableListRouterTableListTypeTagsTag["Key"].asString();
+			if(!valueRouterTableListRouterTableListTypeTagsTag["Value"].isNull())
+				tagsObject.value = valueRouterTableListRouterTableListTypeTagsTag["Value"].asString();
 			routerTableListObject.tags.push_back(tagsObject);
 		}
 		auto allVSwitchIds = value["VSwitchIds"]["VSwitchId"];

vpc/src/model/DescribeRouteTablesResult.cc

@@ -55,58 +55,58 @@ void DescribeRouteTablesResult::parse(const std::string &payload)
 			routeTablesObject.resourceGroupId = valueRouteTablesRouteTable["ResourceGroupId"].asString();
 		if(!valueRouteTablesRouteTable["Status"].isNull())
 			routeTablesObject.status = valueRouteTablesRouteTable["Status"].asString();
-		auto allRouteEntrysNode = allRouteTablesNode["RouteEntrys"]["RouteEntry"];
-		for (auto allRouteTablesNodeRouteEntrysRouteEntry : allRouteEntrysNode)
+		auto allRouteEntrysNode = valueRouteTablesRouteTable["RouteEntrys"]["RouteEntry"];
+		for (auto valueRouteTablesRouteTableRouteEntrysRouteEntry : allRouteEntrysNode)
 		{
 			RouteTable::RouteEntry routeEntrysObject;
-			if(!allRouteTablesNodeRouteEntrysRouteEntry["RouteTableId"].isNull())
-				routeEntrysObject.routeTableId = allRouteTablesNodeRouteEntrysRouteEntry["RouteTableId"].asString();
-			if(!allRouteTablesNodeRouteEntrysRouteEntry["DestinationCidrBlock"].isNull())
-				routeEntrysObject.destinationCidrBlock = allRouteTablesNodeRouteEntrysRouteEntry["DestinationCidrBlock"].asString();
-			if(!allRouteTablesNodeRouteEntrysRouteEntry["Type"].isNull())
-				routeEntrysObject.type = allRouteTablesNodeRouteEntrysRouteEntry["Type"].asString();
-			if(!allRouteTablesNodeRouteEntrysRouteEntry["Status"].isNull())
-				routeEntrysObject.status = allRouteTablesNodeRouteEntrysRouteEntry["Status"].asString();
-			if(!allRouteTablesNodeRouteEntrysRouteEntry["InstanceId"].isNull())
-				routeEntrysObject.instanceId = allRouteTablesNodeRouteEntrysRouteEntry["InstanceId"].asString();
-			if(!allRouteTablesNodeRouteEntrysRouteEntry["NextHopType"].isNull())
-				routeEntrysObject.nextHopType = allRouteTablesNodeRouteEntrysRouteEntry["NextHopType"].asString();
-			if(!allRouteTablesNodeRouteEntrysRouteEntry["RouteEntryName"].isNull())
-				routeEntrysObject.routeEntryName = allRouteTablesNodeRouteEntrysRouteEntry["RouteEntryName"].asString();
-			if(!allRouteTablesNodeRouteEntrysRouteEntry["Description"].isNull())
-				routeEntrysObject.description = allRouteTablesNodeRouteEntrysRouteEntry["Description"].asString();
-			if(!allRouteTablesNodeRouteEntrysRouteEntry["RouteEntryId"].isNull())
-				routeEntrysObject.routeEntryId = allRouteTablesNodeRouteEntrysRouteEntry["RouteEntryId"].asString();
-			if(!allRouteTablesNodeRouteEntrysRouteEntry["NextHopRegionId"].isNull())
-				routeEntrysObject.nextHopRegionId = allRouteTablesNodeRouteEntrysRouteEntry["NextHopRegionId"].asString();
-			if(!allRouteTablesNodeRouteEntrysRouteEntry["NextHopOppsiteType"].isNull())
-				routeEntrysObject.nextHopOppsiteType = allRouteTablesNodeRouteEntrysRouteEntry["NextHopOppsiteType"].asString();
-			if(!allRouteTablesNodeRouteEntrysRouteEntry["NextHopOppsiteInstanceId"].isNull())
-				routeEntrysObject.nextHopOppsiteInstanceId = allRouteTablesNodeRouteEntrysRouteEntry["NextHopOppsiteInstanceId"].asString();
-			if(!allRouteTablesNodeRouteEntrysRouteEntry["NextHopOppsiteRegionId"].isNull())
-				routeEntrysObject.nextHopOppsiteRegionId = allRouteTablesNodeRouteEntrysRouteEntry["NextHopOppsiteRegionId"].asString();
-			if(!allRouteTablesNodeRouteEntrysRouteEntry["PrivateIpAddress"].isNull())
-				routeEntrysObject.privateIpAddress = allRouteTablesNodeRouteEntrysRouteEntry["PrivateIpAddress"].asString();
-			auto allNextHopsNode = allRouteEntrysNode["NextHops"]["NextHop"];
-			for (auto allRouteEntrysNodeNextHopsNextHop : allNextHopsNode)
+			if(!valueRouteTablesRouteTableRouteEntrysRouteEntry["RouteTableId"].isNull())
+				routeEntrysObject.routeTableId = valueRouteTablesRouteTableRouteEntrysRouteEntry["RouteTableId"].asString();
+			if(!valueRouteTablesRouteTableRouteEntrysRouteEntry["DestinationCidrBlock"].isNull())
+				routeEntrysObject.destinationCidrBlock = valueRouteTablesRouteTableRouteEntrysRouteEntry["DestinationCidrBlock"].asString();
+			if(!valueRouteTablesRouteTableRouteEntrysRouteEntry["Type"].isNull())
+				routeEntrysObject.type = valueRouteTablesRouteTableRouteEntrysRouteEntry["Type"].asString();
+			if(!valueRouteTablesRouteTableRouteEntrysRouteEntry["Status"].isNull())
+				routeEntrysObject.status = valueRouteTablesRouteTableRouteEntrysRouteEntry["Status"].asString();
+			if(!valueRouteTablesRouteTableRouteEntrysRouteEntry["InstanceId"].isNull())
+				routeEntrysObject.instanceId = valueRouteTablesRouteTableRouteEntrysRouteEntry["InstanceId"].asString();
+			if(!valueRouteTablesRouteTableRouteEntrysRouteEntry["NextHopType"].isNull())
+				routeEntrysObject.nextHopType = valueRouteTablesRouteTableRouteEntrysRouteEntry["NextHopType"].asString();
+			if(!valueRouteTablesRouteTableRouteEntrysRouteEntry["RouteEntryName"].isNull())
+				routeEntrysObject.routeEntryName = valueRouteTablesRouteTableRouteEntrysRouteEntry["RouteEntryName"].asString();
+			if(!valueRouteTablesRouteTableRouteEntrysRouteEntry["Description"].isNull())
+				routeEntrysObject.description = valueRouteTablesRouteTableRouteEntrysRouteEntry["Description"].asString();
+			if(!valueRouteTablesRouteTableRouteEntrysRouteEntry["RouteEntryId"].isNull())
+				routeEntrysObject.routeEntryId = valueRouteTablesRouteTableRouteEntrysRouteEntry["RouteEntryId"].asString();
+			if(!valueRouteTablesRouteTableRouteEntrysRouteEntry["NextHopRegionId"].isNull())
+				routeEntrysObject.nextHopRegionId = valueRouteTablesRouteTableRouteEntrysRouteEntry["NextHopRegionId"].asString();
+			if(!valueRouteTablesRouteTableRouteEntrysRouteEntry["NextHopOppsiteType"].isNull())
+				routeEntrysObject.nextHopOppsiteType = valueRouteTablesRouteTableRouteEntrysRouteEntry["NextHopOppsiteType"].asString();
+			if(!valueRouteTablesRouteTableRouteEntrysRouteEntry["NextHopOppsiteInstanceId"].isNull())
+				routeEntrysObject.nextHopOppsiteInstanceId = valueRouteTablesRouteTableRouteEntrysRouteEntry["NextHopOppsiteInstanceId"].asString();
+			if(!valueRouteTablesRouteTableRouteEntrysRouteEntry["NextHopOppsiteRegionId"].isNull())
+				routeEntrysObject.nextHopOppsiteRegionId = valueRouteTablesRouteTableRouteEntrysRouteEntry["NextHopOppsiteRegionId"].asString();
+			if(!valueRouteTablesRouteTableRouteEntrysRouteEntry["PrivateIpAddress"].isNull())
+				routeEntrysObject.privateIpAddress = valueRouteTablesRouteTableRouteEntrysRouteEntry["PrivateIpAddress"].asString();
+			auto allNextHopsNode = valueRouteTablesRouteTableRouteEntrysRouteEntry["NextHops"]["NextHop"];
+			for (auto valueRouteTablesRouteTableRouteEntrysRouteEntryNextHopsNextHop : allNextHopsNode)
 			{
 				RouteTable::RouteEntry::NextHop nextHopsObject;
-				if(!allRouteEntrysNodeNextHopsNextHop["NextHopType"].isNull())
-					nextHopsObject.nextHopType = allRouteEntrysNodeNextHopsNextHop["NextHopType"].asString();
-				if(!allRouteEntrysNodeNextHopsNextHop["NextHopId"].isNull())
-					nextHopsObject.nextHopId = allRouteEntrysNodeNextHopsNextHop["NextHopId"].asString();
-				if(!allRouteEntrysNodeNextHopsNextHop["Enabled"].isNull())
-					nextHopsObject.enabled = std::stoi(allRouteEntrysNodeNextHopsNextHop["Enabled"].asString());
-				if(!allRouteEntrysNodeNextHopsNextHop["Weight"].isNull())
-					nextHopsObject.weight = std::stoi(allRouteEntrysNodeNextHopsNextHop["Weight"].asString());
-				if(!allRouteEntrysNodeNextHopsNextHop["NextHopRegionId"].isNull())
-					nextHopsObject.nextHopRegionId = allRouteEntrysNodeNextHopsNextHop["NextHopRegionId"].asString();
-				if(!allRouteEntrysNodeNextHopsNextHop["NextHopOppsiteType"].isNull())
-					nextHopsObject.nextHopOppsiteType = allRouteEntrysNodeNextHopsNextHop["NextHopOppsiteType"].asString();
-				if(!allRouteEntrysNodeNextHopsNextHop["NextHopOppsiteInstanceId"].isNull())
-					nextHopsObject.nextHopOppsiteInstanceId = allRouteEntrysNodeNextHopsNextHop["NextHopOppsiteInstanceId"].asString();
-				if(!allRouteEntrysNodeNextHopsNextHop["NextHopOppsiteRegionId"].isNull())
-					nextHopsObject.nextHopOppsiteRegionId = allRouteEntrysNodeNextHopsNextHop["NextHopOppsiteRegionId"].asString();
+				if(!valueRouteTablesRouteTableRouteEntrysRouteEntryNextHopsNextHop["NextHopType"].isNull())
+					nextHopsObject.nextHopType = valueRouteTablesRouteTableRouteEntrysRouteEntryNextHopsNextHop["NextHopType"].asString();
+				if(!valueRouteTablesRouteTableRouteEntrysRouteEntryNextHopsNextHop["NextHopId"].isNull())
+					nextHopsObject.nextHopId = valueRouteTablesRouteTableRouteEntrysRouteEntryNextHopsNextHop["NextHopId"].asString();
+				if(!valueRouteTablesRouteTableRouteEntrysRouteEntryNextHopsNextHop["Enabled"].isNull())
+					nextHopsObject.enabled = std::stoi(valueRouteTablesRouteTableRouteEntrysRouteEntryNextHopsNextHop["Enabled"].asString());
+				if(!valueRouteTablesRouteTableRouteEntrysRouteEntryNextHopsNextHop["Weight"].isNull())
+					nextHopsObject.weight = std::stoi(valueRouteTablesRouteTableRouteEntrysRouteEntryNextHopsNextHop["Weight"].asString());
+				if(!valueRouteTablesRouteTableRouteEntrysRouteEntryNextHopsNextHop["NextHopRegionId"].isNull())
+					nextHopsObject.nextHopRegionId = valueRouteTablesRouteTableRouteEntrysRouteEntryNextHopsNextHop["NextHopRegionId"].asString();
+				if(!valueRouteTablesRouteTableRouteEntrysRouteEntryNextHopsNextHop["NextHopOppsiteType"].isNull())
+					nextHopsObject.nextHopOppsiteType = valueRouteTablesRouteTableRouteEntrysRouteEntryNextHopsNextHop["NextHopOppsiteType"].asString();
+				if(!valueRouteTablesRouteTableRouteEntrysRouteEntryNextHopsNextHop["NextHopOppsiteInstanceId"].isNull())
+					nextHopsObject.nextHopOppsiteInstanceId = valueRouteTablesRouteTableRouteEntrysRouteEntryNextHopsNextHop["NextHopOppsiteInstanceId"].asString();
+				if(!valueRouteTablesRouteTableRouteEntrysRouteEntryNextHopsNextHop["NextHopOppsiteRegionId"].isNull())
+					nextHopsObject.nextHopOppsiteRegionId = valueRouteTablesRouteTableRouteEntrysRouteEntryNextHopsNextHop["NextHopOppsiteRegionId"].asString();
 				routeEntrysObject.nextHops.push_back(nextHopsObject);
 			}
 			routeTablesObject.routeEntrys.push_back(routeEntrysObject);

vpc/src/model/DescribeSslVpnServersResult.cc

@@ -75,6 +75,8 @@ void DescribeSslVpnServersResult::parse(const std::string &payload)
 			sslVpnServersObject.enableMultiFactorAuth = valueSslVpnServersSslVpnServer["EnableMultiFactorAuth"].asString() == "true";
 		if(!valueSslVpnServersSslVpnServer["IDaaSInstanceId"].isNull())
 			sslVpnServersObject.iDaaSInstanceId = valueSslVpnServersSslVpnServer["IDaaSInstanceId"].asString();
+		if(!valueSslVpnServersSslVpnServer["IDaaSRegionId"].isNull())
+			sslVpnServersObject.iDaaSRegionId = valueSslVpnServersSslVpnServer["IDaaSRegionId"].asString();
 		sslVpnServers_.push_back(sslVpnServersObject);
 	}
 	if(!value["TotalCount"].isNull())

vpc/src/model/DescribeVSwitchAttributesResult.cc

@@ -80,6 +80,10 @@ void DescribeVSwitchAttributesResult::parse(const std::string &payload)
 		resourceGroupId_ = value["ResourceGroupId"].asString();
 	if(!value["NetworkAclId"].isNull())
 		networkAclId_ = value["NetworkAclId"].asString();
+	if(!value["OwnerId"].isNull())
+		ownerId_ = std::stol(value["OwnerId"].asString());
+	if(!value["ShareType"].isNull())
+		shareType_ = value["ShareType"].asString();
 
 }
 
@@ -138,6 +142,11 @@ std::string DescribeVSwitchAttributesResult::getVpcId()const
 	return vpcId_;
 }
 
+long DescribeVSwitchAttributesResult::getOwnerId()const
+{
+	return ownerId_;
+}
+
 std::string DescribeVSwitchAttributesResult::getCreationTime()const
 {
 	return creationTime_;
@@ -158,3 +167,8 @@ std::vector<DescribeVSwitchAttributesResult::CloudResourceSetType> DescribeVSwit
 	return cloudResources_;
 }
 
+std::string DescribeVSwitchAttributesResult::getShareType()const
+{
+	return shareType_;
+}
+

vpc/src/model/DescribeVSwitchesRequest.cc

@@ -175,6 +175,17 @@ void DescribeVSwitchesRequest::setVSwitchId(const std::string& vSwitchId)
 	setParameter("VSwitchId", vSwitchId);
 }
 
+long DescribeVSwitchesRequest::getVSwitchOwnerId()const
+{
+	return vSwitchOwnerId_;
+}
+
+void DescribeVSwitchesRequest::setVSwitchOwnerId(long vSwitchOwnerId)
+{
+	vSwitchOwnerId_ = vSwitchOwnerId;
+	setParameter("VSwitchOwnerId", std::to_string(vSwitchOwnerId));
+}
+
 std::string DescribeVSwitchesRequest::getVpcId()const
 {
 	return vpcId_;

vpc/src/model/DescribeVSwitchesResult.cc

@@ -69,14 +69,18 @@ void DescribeVSwitchesResult::parse(const std::string &payload)
 			vSwitchesObject.resourceGroupId = valueVSwitchesVSwitch["ResourceGroupId"].asString();
 		if(!valueVSwitchesVSwitch["NetworkAclId"].isNull())
 			vSwitchesObject.networkAclId = valueVSwitchesVSwitch["NetworkAclId"].asString();
-		auto allTagsNode = allVSwitchesNode["Tags"]["Tag"];
-		for (auto allVSwitchesNodeTagsTag : allTagsNode)
+		if(!valueVSwitchesVSwitch["OwnerId"].isNull())
+			vSwitchesObject.ownerId = std::stol(valueVSwitchesVSwitch["OwnerId"].asString());
+		if(!valueVSwitchesVSwitch["ShareType"].isNull())
+			vSwitchesObject.shareType = valueVSwitchesVSwitch["ShareType"].asString();
+		auto allTagsNode = valueVSwitchesVSwitch["Tags"]["Tag"];
+		for (auto valueVSwitchesVSwitchTagsTag : allTagsNode)
 		{
 			VSwitch::Tag tagsObject;
-			if(!allVSwitchesNodeTagsTag["Key"].isNull())
-				tagsObject.key = allVSwitchesNodeTagsTag["Key"].asString();
-			if(!allVSwitchesNodeTagsTag["Value"].isNull())
-				tagsObject.value = allVSwitchesNodeTagsTag["Value"].asString();
+			if(!valueVSwitchesVSwitchTagsTag["Key"].isNull())
+				tagsObject.key = valueVSwitchesVSwitchTagsTag["Key"].asString();
+			if(!valueVSwitchesVSwitchTagsTag["Value"].isNull())
+				tagsObject.value = valueVSwitchesVSwitchTagsTag["Value"].asString();
 			vSwitchesObject.tags.push_back(tagsObject);
 		}
 		auto routeTableNode = value["RouteTable"];

vpc/src/model/DescribeVbrHaRequest.cc

@@ -0,0 +1,128 @@
+/*
+ * 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/vpc/model/DescribeVbrHaRequest.h>
+
+using AlibabaCloud::Vpc::Model::DescribeVbrHaRequest;
+
+DescribeVbrHaRequest::DescribeVbrHaRequest() :
+	RpcServiceRequest("vpc", "2016-04-28", "DescribeVbrHa")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeVbrHaRequest::~DescribeVbrHaRequest()
+{}
+
+long DescribeVbrHaRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeVbrHaRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeVbrHaRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void DescribeVbrHaRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string DescribeVbrHaRequest::getVbrHaId()const
+{
+	return vbrHaId_;
+}
+
+void DescribeVbrHaRequest::setVbrHaId(const std::string& vbrHaId)
+{
+	vbrHaId_ = vbrHaId;
+	setParameter("VbrHaId", vbrHaId);
+}
+
+std::string DescribeVbrHaRequest::getVbrId()const
+{
+	return vbrId_;
+}
+
+void DescribeVbrHaRequest::setVbrId(const std::string& vbrId)
+{
+	vbrId_ = vbrId;
+	setParameter("VbrId", vbrId);
+}
+
+std::string DescribeVbrHaRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeVbrHaRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+bool DescribeVbrHaRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void DescribeVbrHaRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string DescribeVbrHaRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeVbrHaRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeVbrHaRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeVbrHaRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DescribeVbrHaRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeVbrHaRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

vpc/src/model/DescribeVbrHaResult.cc

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/vpc/model/DescribeVbrHaResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+DescribeVbrHaResult::DescribeVbrHaResult() :
+	ServiceResult()
+{}
+
+DescribeVbrHaResult::DescribeVbrHaResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeVbrHaResult::~DescribeVbrHaResult()
+{}
+
+void DescribeVbrHaResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["VbrHaId"].isNull())
+		vbrHaId_ = value["VbrHaId"].asString();
+	if(!value["RegionId"].isNull())
+		regionId_ = value["RegionId"].asString();
+	if(!value["Name"].isNull())
+		name_ = value["Name"].asString();
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["VbrId"].isNull())
+		vbrId_ = value["VbrId"].asString();
+	if(!value["CreationTime"].isNull())
+		creationTime_ = value["CreationTime"].asString();
+	if(!value["PeerVbrId"].isNull())
+		peerVbrId_ = value["PeerVbrId"].asString();
+
+}
+
+std::string DescribeVbrHaResult::getStatus()const
+{
+	return status_;
+}
+
+std::string DescribeVbrHaResult::getVbrHaId()const
+{
+	return vbrHaId_;
+}
+
+std::string DescribeVbrHaResult::getDescription()const
+{
+	return description_;
+}
+
+std::string DescribeVbrHaResult::getCreationTime()const
+{
+	return creationTime_;
+}
+
+std::string DescribeVbrHaResult::getRegionId()const
+{
+	return regionId_;
+}
+
+std::string DescribeVbrHaResult::getVbrId()const
+{
+	return vbrId_;
+}
+
+std::string DescribeVbrHaResult::getPeerVbrId()const
+{
+	return peerVbrId_;
+}
+
+std::string DescribeVbrHaResult::getName()const
+{
+	return name_;
+}
+

vpc/src/model/DescribeVirtualBorderRoutersForPhysicalConnectionResult.cc

@@ -79,6 +79,16 @@ void DescribeVirtualBorderRoutersForPhysicalConnectionResult::parse(const std::s
 			virtualBorderRouterForPhysicalConnectionSetObject.pConnVbrBussinessStatus = valueVirtualBorderRouterForPhysicalConnectionSetVirtualBorderRouterForPhysicalConnectionType["PConnVbrBussinessStatus"].asString();
 		if(!valueVirtualBorderRouterForPhysicalConnectionSetVirtualBorderRouterForPhysicalConnectionType["Bandwidth"].isNull())
 			virtualBorderRouterForPhysicalConnectionSetObject.bandwidth = valueVirtualBorderRouterForPhysicalConnectionSetVirtualBorderRouterForPhysicalConnectionType["Bandwidth"].asString();
+		if(!valueVirtualBorderRouterForPhysicalConnectionSetVirtualBorderRouterForPhysicalConnectionType["LocalIpv6GatewayIp"].isNull())
+			virtualBorderRouterForPhysicalConnectionSetObject.localIpv6GatewayIp = valueVirtualBorderRouterForPhysicalConnectionSetVirtualBorderRouterForPhysicalConnectionType["LocalIpv6GatewayIp"].asString();
+		if(!valueVirtualBorderRouterForPhysicalConnectionSetVirtualBorderRouterForPhysicalConnectionType["PeerIpv6GatewayIp"].isNull())
+			virtualBorderRouterForPhysicalConnectionSetObject.peerIpv6GatewayIp = valueVirtualBorderRouterForPhysicalConnectionSetVirtualBorderRouterForPhysicalConnectionType["PeerIpv6GatewayIp"].asString();
+		if(!valueVirtualBorderRouterForPhysicalConnectionSetVirtualBorderRouterForPhysicalConnectionType["PeeringIpv6SubnetMask"].isNull())
+			virtualBorderRouterForPhysicalConnectionSetObject.peeringIpv6SubnetMask = valueVirtualBorderRouterForPhysicalConnectionSetVirtualBorderRouterForPhysicalConnectionType["PeeringIpv6SubnetMask"].asString();
+		if(!valueVirtualBorderRouterForPhysicalConnectionSetVirtualBorderRouterForPhysicalConnectionType["EnableIpv6"].isNull())
+			virtualBorderRouterForPhysicalConnectionSetObject.enableIpv6 = valueVirtualBorderRouterForPhysicalConnectionSetVirtualBorderRouterForPhysicalConnectionType["EnableIpv6"].asString() == "true";
+		if(!valueVirtualBorderRouterForPhysicalConnectionSetVirtualBorderRouterForPhysicalConnectionType["BandwidthStatus"].isNull())
+			virtualBorderRouterForPhysicalConnectionSetObject.bandwidthStatus = valueVirtualBorderRouterForPhysicalConnectionSetVirtualBorderRouterForPhysicalConnectionType["BandwidthStatus"].asString();
 		virtualBorderRouterForPhysicalConnectionSet_.push_back(virtualBorderRouterForPhysicalConnectionSetObject);
 	}
 	if(!value["PageNumber"].isNull())

vpc/src/model/DescribeVirtualBorderRoutersResult.cc

@@ -95,42 +95,62 @@ void DescribeVirtualBorderRoutersResult::parse(const std::string &payload)
 			virtualBorderRouterSetObject.minRxInterval = std::stol(valueVirtualBorderRouterSetVirtualBorderRouterType["MinRxInterval"].asString());
 		if(!valueVirtualBorderRouterSetVirtualBorderRouterType["DetectMultiplier"].isNull())
 			virtualBorderRouterSetObject.detectMultiplier = std::stol(valueVirtualBorderRouterSetVirtualBorderRouterType["DetectMultiplier"].asString());
-		auto allAssociatedPhysicalConnectionsNode = allVirtualBorderRouterSetNode["AssociatedPhysicalConnections"]["AssociatedPhysicalConnection"];
-		for (auto allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection : allAssociatedPhysicalConnectionsNode)
+		if(!valueVirtualBorderRouterSetVirtualBorderRouterType["LocalIpv6GatewayIp"].isNull())
+			virtualBorderRouterSetObject.localIpv6GatewayIp = valueVirtualBorderRouterSetVirtualBorderRouterType["LocalIpv6GatewayIp"].asString();
+		if(!valueVirtualBorderRouterSetVirtualBorderRouterType["PeerIpv6GatewayIp"].isNull())
+			virtualBorderRouterSetObject.peerIpv6GatewayIp = valueVirtualBorderRouterSetVirtualBorderRouterType["PeerIpv6GatewayIp"].asString();
+		if(!valueVirtualBorderRouterSetVirtualBorderRouterType["PeeringIpv6SubnetMask"].isNull())
+			virtualBorderRouterSetObject.peeringIpv6SubnetMask = valueVirtualBorderRouterSetVirtualBorderRouterType["PeeringIpv6SubnetMask"].asString();
+		if(!valueVirtualBorderRouterSetVirtualBorderRouterType["EnableIpv6"].isNull())
+			virtualBorderRouterSetObject.enableIpv6 = valueVirtualBorderRouterSetVirtualBorderRouterType["EnableIpv6"].asString() == "true";
+		if(!valueVirtualBorderRouterSetVirtualBorderRouterType["CloudBoxInstanceId"].isNull())
+			virtualBorderRouterSetObject.cloudBoxInstanceId = valueVirtualBorderRouterSetVirtualBorderRouterType["CloudBoxInstanceId"].asString();
+		auto allAssociatedPhysicalConnectionsNode = valueVirtualBorderRouterSetVirtualBorderRouterType["AssociatedPhysicalConnections"]["AssociatedPhysicalConnection"];
+		for (auto valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection : allAssociatedPhysicalConnectionsNode)
 		{
 			VirtualBorderRouterType::AssociatedPhysicalConnection associatedPhysicalConnectionsObject;
-			if(!allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["CircuitCode"].isNull())
-				associatedPhysicalConnectionsObject.circuitCode = allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["CircuitCode"].asString();
-			if(!allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["VlanInterfaceId"].isNull())
-				associatedPhysicalConnectionsObject.vlanInterfaceId = allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["VlanInterfaceId"].asString();
-			if(!allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["LocalGatewayIp"].isNull())
-				associatedPhysicalConnectionsObject.localGatewayIp = allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["LocalGatewayIp"].asString();
-			if(!allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PeerGatewayIp"].isNull())
-				associatedPhysicalConnectionsObject.peerGatewayIp = allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PeerGatewayIp"].asString();
-			if(!allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PeeringSubnetMask"].isNull())
-				associatedPhysicalConnectionsObject.peeringSubnetMask = allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PeeringSubnetMask"].asString();
-			if(!allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PhysicalConnectionId"].isNull())
-				associatedPhysicalConnectionsObject.physicalConnectionId = allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PhysicalConnectionId"].asString();
-			if(!allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PhysicalConnectionStatus"].isNull())
-				associatedPhysicalConnectionsObject.physicalConnectionStatus = allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PhysicalConnectionStatus"].asString();
-			if(!allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PhysicalConnectionBusinessStatus"].isNull())
-				associatedPhysicalConnectionsObject.physicalConnectionBusinessStatus = allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PhysicalConnectionBusinessStatus"].asString();
-			if(!allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PhysicalConnectionOwnerUid"].isNull())
-				associatedPhysicalConnectionsObject.physicalConnectionOwnerUid = allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PhysicalConnectionOwnerUid"].asString();
-			if(!allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["VlanId"].isNull())
-				associatedPhysicalConnectionsObject.vlanId = allVirtualBorderRouterSetNodeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["VlanId"].asString();
+			if(!valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["CircuitCode"].isNull())
+				associatedPhysicalConnectionsObject.circuitCode = valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["CircuitCode"].asString();
+			if(!valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["VlanInterfaceId"].isNull())
+				associatedPhysicalConnectionsObject.vlanInterfaceId = valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["VlanInterfaceId"].asString();
+			if(!valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["LocalGatewayIp"].isNull())
+				associatedPhysicalConnectionsObject.localGatewayIp = valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["LocalGatewayIp"].asString();
+			if(!valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PeerGatewayIp"].isNull())
+				associatedPhysicalConnectionsObject.peerGatewayIp = valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PeerGatewayIp"].asString();
+			if(!valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PeeringSubnetMask"].isNull())
+				associatedPhysicalConnectionsObject.peeringSubnetMask = valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PeeringSubnetMask"].asString();
+			if(!valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PhysicalConnectionId"].isNull())
+				associatedPhysicalConnectionsObject.physicalConnectionId = valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PhysicalConnectionId"].asString();
+			if(!valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PhysicalConnectionStatus"].isNull())
+				associatedPhysicalConnectionsObject.physicalConnectionStatus = valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PhysicalConnectionStatus"].asString();
+			if(!valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PhysicalConnectionBusinessStatus"].isNull())
+				associatedPhysicalConnectionsObject.physicalConnectionBusinessStatus = valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PhysicalConnectionBusinessStatus"].asString();
+			if(!valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PhysicalConnectionOwnerUid"].isNull())
+				associatedPhysicalConnectionsObject.physicalConnectionOwnerUid = valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PhysicalConnectionOwnerUid"].asString();
+			if(!valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["VlanId"].isNull())
+				associatedPhysicalConnectionsObject.vlanId = valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["VlanId"].asString();
+			if(!valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["LocalIpv6GatewayIp"].isNull())
+				associatedPhysicalConnectionsObject.localIpv6GatewayIp = valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["LocalIpv6GatewayIp"].asString();
+			if(!valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PeerIpv6GatewayIp"].isNull())
+				associatedPhysicalConnectionsObject.peerIpv6GatewayIp = valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PeerIpv6GatewayIp"].asString();
+			if(!valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PeeringIpv6SubnetMask"].isNull())
+				associatedPhysicalConnectionsObject.peeringIpv6SubnetMask = valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["PeeringIpv6SubnetMask"].asString();
+			if(!valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["Status"].isNull())
+				associatedPhysicalConnectionsObject.status = valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["Status"].asString();
+			if(!valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["EnableIpv6"].isNull())
+				associatedPhysicalConnectionsObject.enableIpv6 = valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedPhysicalConnectionsAssociatedPhysicalConnection["EnableIpv6"].asString() == "true";
 			virtualBorderRouterSetObject.associatedPhysicalConnections.push_back(associatedPhysicalConnectionsObject);
 		}
-		auto allAssociatedCensNode = allVirtualBorderRouterSetNode["AssociatedCens"]["AssociatedCen"];
-		for (auto allVirtualBorderRouterSetNodeAssociatedCensAssociatedCen : allAssociatedCensNode)
+		auto allAssociatedCensNode = valueVirtualBorderRouterSetVirtualBorderRouterType["AssociatedCens"]["AssociatedCen"];
+		for (auto valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedCensAssociatedCen : allAssociatedCensNode)
 		{
 			VirtualBorderRouterType::AssociatedCen associatedCensObject;
-			if(!allVirtualBorderRouterSetNodeAssociatedCensAssociatedCen["CenId"].isNull())
-				associatedCensObject.cenId = allVirtualBorderRouterSetNodeAssociatedCensAssociatedCen["CenId"].asString();
-			if(!allVirtualBorderRouterSetNodeAssociatedCensAssociatedCen["CenOwnerId"].isNull())
-				associatedCensObject.cenOwnerId = std::stol(allVirtualBorderRouterSetNodeAssociatedCensAssociatedCen["CenOwnerId"].asString());
-			if(!allVirtualBorderRouterSetNodeAssociatedCensAssociatedCen["CenStatus"].isNull())
-				associatedCensObject.cenStatus = allVirtualBorderRouterSetNodeAssociatedCensAssociatedCen["CenStatus"].asString();
+			if(!valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedCensAssociatedCen["CenId"].isNull())
+				associatedCensObject.cenId = valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedCensAssociatedCen["CenId"].asString();
+			if(!valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedCensAssociatedCen["CenOwnerId"].isNull())
+				associatedCensObject.cenOwnerId = std::stol(valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedCensAssociatedCen["CenOwnerId"].asString());
+			if(!valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedCensAssociatedCen["CenStatus"].isNull())
+				associatedCensObject.cenStatus = valueVirtualBorderRouterSetVirtualBorderRouterTypeAssociatedCensAssociatedCen["CenStatus"].asString();
 			virtualBorderRouterSetObject.associatedCens.push_back(associatedCensObject);
 		}
 		virtualBorderRouterSet_.push_back(virtualBorderRouterSetObject);

vpc/src/model/DescribeVpcAttributeResult.cc

@@ -61,6 +61,16 @@ void DescribeVpcAttributeResult::parse(const std::string &payload)
 			cloudResourcesObject.resourceCount = std::stoi(valueCloudResourcesCloudResourceSetType["ResourceCount"].asString());
 		cloudResources_.push_back(cloudResourcesObject);
 	}
+	auto allIpv6CidrBlocksNode = value["Ipv6CidrBlocks"]["Ipv6CidrBlock"];
+	for (auto valueIpv6CidrBlocksIpv6CidrBlock : allIpv6CidrBlocksNode)
+	{
+		Ipv6CidrBlock ipv6CidrBlocksObject;
+		if(!valueIpv6CidrBlocksIpv6CidrBlock["Ipv6CidrBlock"].isNull())
+			ipv6CidrBlocksObject.ipv6CidrBlock = valueIpv6CidrBlocksIpv6CidrBlock["Ipv6CidrBlock"].asString();
+		if(!valueIpv6CidrBlocksIpv6CidrBlock["Ipv6Isp"].isNull())
+			ipv6CidrBlocksObject.ipv6Isp = valueIpv6CidrBlocksIpv6CidrBlock["Ipv6Isp"].asString();
+		ipv6CidrBlocks_.push_back(ipv6CidrBlocksObject);
+	}
 	auto allVSwitchIds = value["VSwitchIds"]["VSwitchId"];
 	for (const auto &item : allVSwitchIds)
 		vSwitchIds_.push_back(item.asString());
@@ -96,6 +106,12 @@ void DescribeVpcAttributeResult::parse(const std::string &payload)
 		resourceGroupId_ = value["ResourceGroupId"].asString();
 	if(!value["NetworkAclNum"].isNull())
 		networkAclNum_ = value["NetworkAclNum"].asString();
+	if(!value["OwnerId"].isNull())
+		ownerId_ = std::stol(value["OwnerId"].asString());
+	if(!value["DhcpOptionsSetId"].isNull())
+		dhcpOptionsSetId_ = value["DhcpOptionsSetId"].asString();
+	if(!value["DhcpOptionsSetStatus"].isNull())
+		dhcpOptionsSetStatus_ = value["DhcpOptionsSetStatus"].asString();
 
 }
 
@@ -114,6 +130,11 @@ std::string DescribeVpcAttributeResult::getDescription()const
 	return description_;
 }
 
+std::string DescribeVpcAttributeResult::getDhcpOptionsSetStatus()const
+{
+	return dhcpOptionsSetStatus_;
+}
+
 bool DescribeVpcAttributeResult::getClassicLinkEnabled()const
 {
 	return classicLinkEnabled_;
@@ -154,11 +175,21 @@ std::string DescribeVpcAttributeResult::getVRouterId()const
 	return vRouterId_;
 }
 
+std::string DescribeVpcAttributeResult::getDhcpOptionsSetId()const
+{
+	return dhcpOptionsSetId_;
+}
+
 std::string DescribeVpcAttributeResult::getVpcId()const
 {
 	return vpcId_;
 }
 
+long DescribeVpcAttributeResult::getOwnerId()const
+{
+	return ownerId_;
+}
+
 std::vector<DescribeVpcAttributeResult::AssociatedCen> DescribeVpcAttributeResult::getAssociatedCens()const
 {
 	return associatedCens_;
@@ -179,6 +210,11 @@ std::string DescribeVpcAttributeResult::getRegionId()const
 	return regionId_;
 }
 
+std::vector<DescribeVpcAttributeResult::Ipv6CidrBlock> DescribeVpcAttributeResult::getIpv6CidrBlocks()const
+{
+	return ipv6CidrBlocks_;
+}
+
 std::string DescribeVpcAttributeResult::getIpv6CidrBlock()const
 {
 	return ipv6CidrBlock_;

vpc/src/model/DescribeVpcsRequest.cc

@@ -38,6 +38,17 @@ void DescribeVpcsRequest::setResourceOwnerId(long resourceOwnerId)
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+long DescribeVpcsRequest::getVpcOwnerId()const
+{
+	return vpcOwnerId_;
+}
+
+void DescribeVpcsRequest::setVpcOwnerId(long vpcOwnerId)
+{
+	vpcOwnerId_ = vpcOwnerId;
+	setParameter("VpcOwnerId", std::to_string(vpcOwnerId));
+}
+
 int DescribeVpcsRequest::getPageNumber()const
 {
 	return pageNumber_;
@@ -131,6 +142,17 @@ void DescribeVpcsRequest::setDryRun(bool dryRun)
 	setParameter("DryRun", dryRun ? "true" : "false");
 }
 
+std::string DescribeVpcsRequest::getDhcpOptionsSetId()const
+{
+	return dhcpOptionsSetId_;
+}
+
+void DescribeVpcsRequest::setDhcpOptionsSetId(const std::string& dhcpOptionsSetId)
+{
+	dhcpOptionsSetId_ = dhcpOptionsSetId;
+	setParameter("DhcpOptionsSetId", dhcpOptionsSetId);
+}
+
 std::string DescribeVpcsRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -153,6 +175,17 @@ void DescribeVpcsRequest::setOwnerAccount(const std::string& ownerAccount)
 	setParameter("OwnerAccount", ownerAccount);
 }
 
+bool DescribeVpcsRequest::getAdvancedFeature()const
+{
+	return advancedFeature_;
+}
+
+void DescribeVpcsRequest::setAdvancedFeature(bool advancedFeature)
+{
+	advancedFeature_ = advancedFeature;
+	setParameter("AdvancedFeature", advancedFeature ? "true" : "false");
+}
+
 long DescribeVpcsRequest::getOwnerId()const
 {
 	return ownerId_;

vpc/src/model/DescribeVpcsResult.cc

@@ -69,16 +69,36 @@ void DescribeVpcsResult::parse(const std::string &payload)
 			vpcsObject.resourceGroupId = valueVpcsVpc["ResourceGroupId"].asString();
 		if(!valueVpcsVpc["CenStatus"].isNull())
 			vpcsObject.cenStatus = valueVpcsVpc["CenStatus"].asString();
-		auto allTagsNode = allVpcsNode["Tags"]["Tag"];
-		for (auto allVpcsNodeTagsTag : allTagsNode)
+		if(!valueVpcsVpc["OwnerId"].isNull())
+			vpcsObject.ownerId = std::stol(valueVpcsVpc["OwnerId"].asString());
+		if(!valueVpcsVpc["SupportAdvancedFeature"].isNull())
+			vpcsObject.supportAdvancedFeature = valueVpcsVpc["SupportAdvancedFeature"].asString() == "true";
+		if(!valueVpcsVpc["AdvancedResource"].isNull())
+			vpcsObject.advancedResource = valueVpcsVpc["AdvancedResource"].asString() == "true";
+		if(!valueVpcsVpc["DhcpOptionsSetId"].isNull())
+			vpcsObject.dhcpOptionsSetId = valueVpcsVpc["DhcpOptionsSetId"].asString();
+		if(!valueVpcsVpc["DhcpOptionsSetStatus"].isNull())
+			vpcsObject.dhcpOptionsSetStatus = valueVpcsVpc["DhcpOptionsSetStatus"].asString();
+		auto allTagsNode = valueVpcsVpc["Tags"]["Tag"];
+		for (auto valueVpcsVpcTagsTag : allTagsNode)
 		{
 			Vpc::Tag tagsObject;
-			if(!allVpcsNodeTagsTag["Key"].isNull())
-				tagsObject.key = allVpcsNodeTagsTag["Key"].asString();
-			if(!allVpcsNodeTagsTag["Value"].isNull())
-				tagsObject.value = allVpcsNodeTagsTag["Value"].asString();
+			if(!valueVpcsVpcTagsTag["Key"].isNull())
+				tagsObject.key = valueVpcsVpcTagsTag["Key"].asString();
+			if(!valueVpcsVpcTagsTag["Value"].isNull())
+				tagsObject.value = valueVpcsVpcTagsTag["Value"].asString();
 			vpcsObject.tags.push_back(tagsObject);
 		}
+		auto allIpv6CidrBlocksNode = valueVpcsVpc["Ipv6CidrBlocks"]["Ipv6CidrBlock"];
+		for (auto valueVpcsVpcIpv6CidrBlocksIpv6CidrBlock : allIpv6CidrBlocksNode)
+		{
+			Vpc::Ipv6CidrBlock ipv6CidrBlocksObject;
+			if(!valueVpcsVpcIpv6CidrBlocksIpv6CidrBlock["Ipv6CidrBlock"].isNull())
+				ipv6CidrBlocksObject.ipv6CidrBlock = valueVpcsVpcIpv6CidrBlocksIpv6CidrBlock["Ipv6CidrBlock"].asString();
+			if(!valueVpcsVpcIpv6CidrBlocksIpv6CidrBlock["Ipv6Isp"].isNull())
+				ipv6CidrBlocksObject.ipv6Isp = valueVpcsVpcIpv6CidrBlocksIpv6CidrBlock["Ipv6Isp"].asString();
+			vpcsObject.ipv6CidrBlocks.push_back(ipv6CidrBlocksObject);
+		}
 		auto allVSwitchIds = value["VSwitchIds"]["VSwitchId"];
 		for (auto value : allVSwitchIds)
 			vpcsObject.vSwitchIds.push_back(value.asString());

vpc/src/model/DescribeVpnConnectionResult.cc

@@ -80,6 +80,21 @@ void DescribeVpnConnectionResult::parse(const std::string &payload)
 		vcoHealthCheck_.retry = std::stoi(vcoHealthCheckNode["Retry"].asString());
 	if(!vcoHealthCheckNode["Status"].isNull())
 		vcoHealthCheck_.status = vcoHealthCheckNode["Status"].asString();
+	auto vpnBgpConfigNode = value["VpnBgpConfig"];
+	if(!vpnBgpConfigNode["EnableBgp"].isNull())
+		vpnBgpConfig_.enableBgp = vpnBgpConfigNode["EnableBgp"].asString();
+	if(!vpnBgpConfigNode["TunnelCidr"].isNull())
+		vpnBgpConfig_.tunnelCidr = vpnBgpConfigNode["TunnelCidr"].asString();
+	if(!vpnBgpConfigNode["LocalBgpIp"].isNull())
+		vpnBgpConfig_.localBgpIp = vpnBgpConfigNode["LocalBgpIp"].asString();
+	if(!vpnBgpConfigNode["PeerBgpIp"].isNull())
+		vpnBgpConfig_.peerBgpIp = vpnBgpConfigNode["PeerBgpIp"].asString();
+	if(!vpnBgpConfigNode["LocalAsn"].isNull())
+		vpnBgpConfig_.localAsn = vpnBgpConfigNode["LocalAsn"].asString();
+	if(!vpnBgpConfigNode["PeerAsn"].isNull())
+		vpnBgpConfig_.peerAsn = vpnBgpConfigNode["PeerAsn"].asString();
+	if(!vpnBgpConfigNode["Status"].isNull())
+		vpnBgpConfig_.status = vpnBgpConfigNode["Status"].asString();
 	if(!value["VpnConnectionId"].isNull())
 		vpnConnectionId_ = value["VpnConnectionId"].asString();
 	if(!value["CustomerGatewayId"].isNull())
@@ -102,6 +117,8 @@ void DescribeVpnConnectionResult::parse(const std::string &payload)
 		enableDpd_ = value["EnableDpd"].asString() == "true";
 	if(!value["EnableNatTraversal"].isNull())
 		enableNatTraversal_ = value["EnableNatTraversal"].asString() == "true";
+	if(!value["RemoteCaCertificate"].isNull())
+		remoteCaCertificate_ = value["RemoteCaCertificate"].asString();
 
 }
 
@@ -155,6 +172,11 @@ DescribeVpnConnectionResult::IpsecConfig DescribeVpnConnectionResult::getIpsecCo
 	return ipsecConfig_;
 }
 
+std::string DescribeVpnConnectionResult::getRemoteCaCertificate()const
+{
+	return remoteCaCertificate_;
+}
+
 std::string DescribeVpnConnectionResult::getVpnConnectionId()const
 {
 	return vpnConnectionId_;
@@ -175,3 +197,8 @@ bool DescribeVpnConnectionResult::getEnableDpd()const
 	return enableDpd_;
 }
 
+DescribeVpnConnectionResult::VpnBgpConfig DescribeVpnConnectionResult::getVpnBgpConfig()const
+{
+	return vpnBgpConfig_;
+}
+

vpc/src/model/DescribeVpnConnectionsResult.cc

@@ -65,6 +65,8 @@ void DescribeVpnConnectionsResult::parse(const std::string &payload)
 			vpnConnectionsObject.enableDpd = valueVpnConnectionsVpnConnection["EnableDpd"].asString() == "true";
 		if(!valueVpnConnectionsVpnConnection["EnableNatTraversal"].isNull())
 			vpnConnectionsObject.enableNatTraversal = valueVpnConnectionsVpnConnection["EnableNatTraversal"].asString() == "true";
+		if(!valueVpnConnectionsVpnConnection["RemoteCaCertificate"].isNull())
+			vpnConnectionsObject.remoteCaCertificate = valueVpnConnectionsVpnConnection["RemoteCaCertificate"].asString();
 		auto ikeConfigNode = value["IkeConfig"];
 		if(!ikeConfigNode["Psk"].isNull())
 			vpnConnectionsObject.ikeConfig.psk = ikeConfigNode["Psk"].asString();
@@ -106,6 +108,19 @@ void DescribeVpnConnectionsResult::parse(const std::string &payload)
 			vpnConnectionsObject.vcoHealthCheck.retry = std::stoi(vcoHealthCheckNode["Retry"].asString());
 		if(!vcoHealthCheckNode["Status"].isNull())
 			vpnConnectionsObject.vcoHealthCheck.status = vcoHealthCheckNode["Status"].asString();
+		auto vpnBgpConfigNode = value["VpnBgpConfig"];
+		if(!vpnBgpConfigNode["TunnelCidr"].isNull())
+			vpnConnectionsObject.vpnBgpConfig.tunnelCidr = vpnBgpConfigNode["TunnelCidr"].asString();
+		if(!vpnBgpConfigNode["LocalBgpIp"].isNull())
+			vpnConnectionsObject.vpnBgpConfig.localBgpIp = vpnBgpConfigNode["LocalBgpIp"].asString();
+		if(!vpnBgpConfigNode["PeerBgpIp"].isNull())
+			vpnConnectionsObject.vpnBgpConfig.peerBgpIp = vpnBgpConfigNode["PeerBgpIp"].asString();
+		if(!vpnBgpConfigNode["LocalAsn"].isNull())
+			vpnConnectionsObject.vpnBgpConfig.localAsn = vpnBgpConfigNode["LocalAsn"].asString();
+		if(!vpnBgpConfigNode["PeerAsn"].isNull())
+			vpnConnectionsObject.vpnBgpConfig.peerAsn = vpnBgpConfigNode["PeerAsn"].asString();
+		if(!vpnBgpConfigNode["Status"].isNull())
+			vpnConnectionsObject.vpnBgpConfig.status = vpnBgpConfigNode["Status"].asString();
 		vpnConnections_.push_back(vpnConnectionsObject);
 	}
 	if(!value["TotalCount"].isNull())

vpc/src/model/DescribeVpnGatewayRequest.cc

@@ -38,6 +38,17 @@ void DescribeVpnGatewayRequest::setResourceOwnerId(long resourceOwnerId)
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+bool DescribeVpnGatewayRequest::getIncludeReservationData()const
+{
+	return includeReservationData_;
+}
+
+void DescribeVpnGatewayRequest::setIncludeReservationData(bool includeReservationData)
+{
+	includeReservationData_ = includeReservationData;
+	setParameter("IncludeReservationData", includeReservationData ? "true" : "false");
+}
+
 std::string DescribeVpnGatewayRequest::getRegionId()const
 {
 	return regionId_;

vpc/src/model/DescribeVpnGatewayResult.cc

@@ -39,6 +39,31 @@ void DescribeVpnGatewayResult::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["Key"].isNull())
+			tagsObject.key = valueTagsTag["Key"].asString();
+		if(!valueTagsTag["Value"].isNull())
+			tagsObject.value = valueTagsTag["Value"].asString();
+		tags_.push_back(tagsObject);
+	}
+	auto reservationDataNode = value["ReservationData"];
+	if(!reservationDataNode["Status"].isNull())
+		reservationData_.status = reservationDataNode["Status"].asString();
+	if(!reservationDataNode["ReservationEndTime"].isNull())
+		reservationData_.reservationEndTime = reservationDataNode["ReservationEndTime"].asString();
+	if(!reservationDataNode["ReservationOrderType"].isNull())
+		reservationData_.reservationOrderType = reservationDataNode["ReservationOrderType"].asString();
+	if(!reservationDataNode["ReservationSpec"].isNull())
+		reservationData_.reservationSpec = reservationDataNode["ReservationSpec"].asString();
+	if(!reservationDataNode["ReservationIpsec"].isNull())
+		reservationData_.reservationIpsec = reservationDataNode["ReservationIpsec"].asString();
+	if(!reservationDataNode["ReservationSsl"].isNull())
+		reservationData_.reservationSsl = reservationDataNode["ReservationSsl"].asString();
+	if(!reservationDataNode["ReservationMaxConnections"].isNull())
+		reservationData_.reservationMaxConnections = std::stoi(reservationDataNode["ReservationMaxConnections"].asString());
 	if(!value["VpnGatewayId"].isNull())
 		vpnGatewayId_ = value["VpnGatewayId"].asString();
 	if(!value["VpcId"].isNull())
@@ -71,6 +96,12 @@ void DescribeVpnGatewayResult::parse(const std::string &payload)
 		sslMaxConnections_ = std::stol(value["SslMaxConnections"].asString());
 	if(!value["Tag"].isNull())
 		tag_ = value["Tag"].asString();
+	if(!value["EnableBgp"].isNull())
+		enableBgp_ = value["EnableBgp"].asString() == "true";
+	if(!value["AutoPropagate"].isNull())
+		autoPropagate_ = value["AutoPropagate"].asString() == "true";
+	if(!value["VpnType"].isNull())
+		vpnType_ = value["VpnType"].asString();
 
 }
 
@@ -89,11 +120,21 @@ std::string DescribeVpnGatewayResult::getSslVpn()const
 	return sslVpn_;
 }
 
+std::string DescribeVpnGatewayResult::getVpnType()const
+{
+	return vpnType_;
+}
+
 std::string DescribeVpnGatewayResult::getDescription()const
 {
 	return description_;
 }
 
+bool DescribeVpnGatewayResult::getEnableBgp()const
+{
+	return enableBgp_;
+}
+
 long DescribeVpnGatewayResult::getEndTime()const
 {
 	return endTime_;
@@ -109,6 +150,11 @@ long DescribeVpnGatewayResult::getCreateTime()const
 	return createTime_;
 }
 
+bool DescribeVpnGatewayResult::getAutoPropagate()const
+{
+	return autoPropagate_;
+}
+
 std::string DescribeVpnGatewayResult::getBusinessStatus()const
 {
 	return businessStatus_;
@@ -154,3 +200,13 @@ long DescribeVpnGatewayResult::getSslMaxConnections()const
 	return sslMaxConnections_;
 }
 
+std::vector<DescribeVpnGatewayResult::Tag> DescribeVpnGatewayResult::getTags()const
+{
+	return tags_;
+}
+
+DescribeVpnGatewayResult::ReservationData DescribeVpnGatewayResult::getReservationData()const
+{
+	return reservationData_;
+}
+

vpc/src/model/DescribeVpnGatewaysRequest.cc

@@ -38,6 +38,17 @@ void DescribeVpnGatewaysRequest::setResourceOwnerId(long resourceOwnerId)
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+bool DescribeVpnGatewaysRequest::getIncludeReservationData()const
+{
+	return includeReservationData_;
+}
+
+void DescribeVpnGatewaysRequest::setIncludeReservationData(bool includeReservationData)
+{
+	includeReservationData_ = includeReservationData;
+	setParameter("IncludeReservationData", includeReservationData ? "true" : "false");
+}
+
 int DescribeVpnGatewaysRequest::getPageNumber()const
 {
 	return pageNumber_;
@@ -71,6 +82,22 @@ void DescribeVpnGatewaysRequest::setPageSize(int pageSize)
 	setParameter("PageSize", std::to_string(pageSize));
 }
 
+std::vector<DescribeVpnGatewaysRequest::Tag> DescribeVpnGatewaysRequest::getTag()const
+{
+	return tag_;
+}
+
+void DescribeVpnGatewaysRequest::setTag(const std::vector<Tag>& tag)
+{
+	tag_ = tag;
+	for(int dep1 = 0; dep1!= tag.size(); dep1++) {
+		auto tagObj = tag.at(dep1);
+		std::string tagObjStr = "Tag." + std::to_string(dep1 + 1);
+		setParameter(tagObjStr + ".Value", tagObj.value);
+		setParameter(tagObjStr + ".Key", tagObj.key);
+	}
+}
+
 std::string DescribeVpnGatewaysRequest::getBusinessStatus()const
 {
 	return businessStatus_;

vpc/src/model/DescribeVpnGatewaysResult.cc

@@ -75,6 +75,37 @@ void DescribeVpnGatewaysResult::parse(const std::string &payload)
 			vpnGatewaysObject.sslMaxConnections = std::stol(valueVpnGatewaysVpnGateway["SslMaxConnections"].asString());
 		if(!valueVpnGatewaysVpnGateway["Tag"].isNull())
 			vpnGatewaysObject.tag = valueVpnGatewaysVpnGateway["Tag"].asString();
+		if(!valueVpnGatewaysVpnGateway["EnableBgp"].isNull())
+			vpnGatewaysObject.enableBgp = valueVpnGatewaysVpnGateway["EnableBgp"].asString() == "true";
+		if(!valueVpnGatewaysVpnGateway["AutoPropagate"].isNull())
+			vpnGatewaysObject.autoPropagate = valueVpnGatewaysVpnGateway["AutoPropagate"].asString() == "true";
+		if(!valueVpnGatewaysVpnGateway["VpnType"].isNull())
+			vpnGatewaysObject.vpnType = valueVpnGatewaysVpnGateway["VpnType"].asString();
+		auto allTagsNode = valueVpnGatewaysVpnGateway["Tags"]["Tag"];
+		for (auto valueVpnGatewaysVpnGatewayTagsTag : allTagsNode)
+		{
+			VpnGateway::Tag tagsObject;
+			if(!valueVpnGatewaysVpnGatewayTagsTag["Key"].isNull())
+				tagsObject.key = valueVpnGatewaysVpnGatewayTagsTag["Key"].asString();
+			if(!valueVpnGatewaysVpnGatewayTagsTag["Value"].isNull())
+				tagsObject.value = valueVpnGatewaysVpnGatewayTagsTag["Value"].asString();
+			vpnGatewaysObject.tags.push_back(tagsObject);
+		}
+		auto reservationDataNode = value["ReservationData"];
+		if(!reservationDataNode["Status"].isNull())
+			vpnGatewaysObject.reservationData.status = reservationDataNode["Status"].asString();
+		if(!reservationDataNode["ReservationEndTime"].isNull())
+			vpnGatewaysObject.reservationData.reservationEndTime = reservationDataNode["ReservationEndTime"].asString();
+		if(!reservationDataNode["ReservationOrderType"].isNull())
+			vpnGatewaysObject.reservationData.reservationOrderType = reservationDataNode["ReservationOrderType"].asString();
+		if(!reservationDataNode["ReservationSpec"].isNull())
+			vpnGatewaysObject.reservationData.reservationSpec = reservationDataNode["ReservationSpec"].asString();
+		if(!reservationDataNode["ReservationIpsec"].isNull())
+			vpnGatewaysObject.reservationData.reservationIpsec = reservationDataNode["ReservationIpsec"].asString();
+		if(!reservationDataNode["ReservationSsl"].isNull())
+			vpnGatewaysObject.reservationData.reservationSsl = reservationDataNode["ReservationSsl"].asString();
+		if(!reservationDataNode["ReservationMaxConnections"].isNull())
+			vpnGatewaysObject.reservationData.reservationMaxConnections = std::stoi(reservationDataNode["ReservationMaxConnections"].asString());
 		vpnGateways_.push_back(vpnGatewaysObject);
 	}
 	if(!value["TotalCount"].isNull())

vpc/src/model/DescribeVpnRouteEntriesRequest.cc

@@ -71,6 +71,17 @@ void DescribeVpnRouteEntriesRequest::setPageSize(int pageSize)
 	setParameter("PageSize", std::to_string(pageSize));
 }
 
+std::string DescribeVpnRouteEntriesRequest::getRouteEntryType()const
+{
+	return routeEntryType_;
+}
+
+void DescribeVpnRouteEntriesRequest::setRouteEntryType(const std::string& routeEntryType)
+{
+	routeEntryType_ = routeEntryType;
+	setParameter("RouteEntryType", routeEntryType);
+}
+
 std::string DescribeVpnRouteEntriesRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;