Generated 2017-11-10 for Ens.

ens/src/EnsClient.cc

@@ -1599,6 +1599,78 @@ EnsClient::CreateSnatEntryOutcomeCallable EnsClient::createSnatEntryCallable(con
 	return task->get_future();
 }
 
+EnsClient::CreateStorageGatewayOutcome EnsClient::createStorageGateway(const CreateStorageGatewayRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateStorageGatewayOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateStorageGatewayOutcome(CreateStorageGatewayResult(outcome.result()));
+	else
+		return CreateStorageGatewayOutcome(outcome.error());
+}
+
+void EnsClient::createStorageGatewayAsync(const CreateStorageGatewayRequest& request, const CreateStorageGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createStorageGateway(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EnsClient::CreateStorageGatewayOutcomeCallable EnsClient::createStorageGatewayCallable(const CreateStorageGatewayRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateStorageGatewayOutcome()>>(
+			[this, request]()
+			{
+			return this->createStorageGateway(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EnsClient::CreateStorageVolumeOutcome EnsClient::createStorageVolume(const CreateStorageVolumeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateStorageVolumeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateStorageVolumeOutcome(CreateStorageVolumeResult(outcome.result()));
+	else
+		return CreateStorageVolumeOutcome(outcome.error());
+}
+
+void EnsClient::createStorageVolumeAsync(const CreateStorageVolumeRequest& request, const CreateStorageVolumeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createStorageVolume(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EnsClient::CreateStorageVolumeOutcomeCallable EnsClient::createStorageVolumeCallable(const CreateStorageVolumeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateStorageVolumeOutcome()>>(
+			[this, request]()
+			{
+			return this->createStorageVolume(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EnsClient::CreateVSwitchOutcome EnsClient::createVSwitch(const CreateVSwitchRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2535,6 +2607,78 @@ EnsClient::DeleteSnatIpForSnatEntryOutcomeCallable EnsClient::deleteSnatIpForSna
 	return task->get_future();
 }
 
+EnsClient::DeleteStorageGatewayOutcome EnsClient::deleteStorageGateway(const DeleteStorageGatewayRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteStorageGatewayOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteStorageGatewayOutcome(DeleteStorageGatewayResult(outcome.result()));
+	else
+		return DeleteStorageGatewayOutcome(outcome.error());
+}
+
+void EnsClient::deleteStorageGatewayAsync(const DeleteStorageGatewayRequest& request, const DeleteStorageGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteStorageGateway(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EnsClient::DeleteStorageGatewayOutcomeCallable EnsClient::deleteStorageGatewayCallable(const DeleteStorageGatewayRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteStorageGatewayOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteStorageGateway(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EnsClient::DeleteStorageVolumeOutcome EnsClient::deleteStorageVolume(const DeleteStorageVolumeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteStorageVolumeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteStorageVolumeOutcome(DeleteStorageVolumeResult(outcome.result()));
+	else
+		return DeleteStorageVolumeOutcome(outcome.error());
+}
+
+void EnsClient::deleteStorageVolumeAsync(const DeleteStorageVolumeRequest& request, const DeleteStorageVolumeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteStorageVolume(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EnsClient::DeleteStorageVolumeOutcomeCallable EnsClient::deleteStorageVolumeCallable(const DeleteStorageVolumeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteStorageVolumeOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteStorageVolume(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EnsClient::DeleteVSwitchOutcome EnsClient::deleteVSwitch(const DeleteVSwitchRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -5595,6 +5739,78 @@ EnsClient::DescribeSnatTableEntriesOutcomeCallable EnsClient::describeSnatTableE
 	return task->get_future();
 }
 
+EnsClient::DescribeStorageGatewayOutcome EnsClient::describeStorageGateway(const DescribeStorageGatewayRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeStorageGatewayOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeStorageGatewayOutcome(DescribeStorageGatewayResult(outcome.result()));
+	else
+		return DescribeStorageGatewayOutcome(outcome.error());
+}
+
+void EnsClient::describeStorageGatewayAsync(const DescribeStorageGatewayRequest& request, const DescribeStorageGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeStorageGateway(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EnsClient::DescribeStorageGatewayOutcomeCallable EnsClient::describeStorageGatewayCallable(const DescribeStorageGatewayRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeStorageGatewayOutcome()>>(
+			[this, request]()
+			{
+			return this->describeStorageGateway(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EnsClient::DescribeStorageVolumeOutcome EnsClient::describeStorageVolume(const DescribeStorageVolumeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeStorageVolumeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeStorageVolumeOutcome(DescribeStorageVolumeResult(outcome.result()));
+	else
+		return DescribeStorageVolumeOutcome(outcome.error());
+}
+
+void EnsClient::describeStorageVolumeAsync(const DescribeStorageVolumeRequest& request, const DescribeStorageVolumeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeStorageVolume(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EnsClient::DescribeStorageVolumeOutcomeCallable EnsClient::describeStorageVolumeCallable(const DescribeStorageVolumeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeStorageVolumeOutcome()>>(
+			[this, request]()
+			{
+			return this->describeStorageVolume(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EnsClient::DescribeUserBandWidthDataOutcome EnsClient::describeUserBandWidthData(const DescribeUserBandWidthDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -6963,6 +7179,42 @@ EnsClient::PreloadRegionSDGOutcomeCallable EnsClient::preloadRegionSDGCallable(c
 	return task->get_future();
 }
 
+EnsClient::PrepareUploadOutcome EnsClient::prepareUpload(const PrepareUploadRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PrepareUploadOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PrepareUploadOutcome(PrepareUploadResult(outcome.result()));
+	else
+		return PrepareUploadOutcome(outcome.error());
+}
+
+void EnsClient::prepareUploadAsync(const PrepareUploadRequest& request, const PrepareUploadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, prepareUpload(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EnsClient::PrepareUploadOutcomeCallable EnsClient::prepareUploadCallable(const PrepareUploadRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PrepareUploadOutcome()>>(
+			[this, request]()
+			{
+			return this->prepareUpload(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EnsClient::PushApplicationDataOutcome EnsClient::pushApplicationData(const PushApplicationDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

ens/src/model/CreateLoadBalancerHTTPListenerRequest.cc

@@ -133,6 +133,15 @@ void CreateLoadBalancerHTTPListenerRequest::setHealthCheckInterval(int healthChe
   setParameter(std::string("HealthCheckInterval"), std::to_string(healthCheckInterval));
 }
 
+int CreateLoadBalancerHTTPListenerRequest::getBackendServerPort() const {
+  return backendServerPort_;
+}
+
+void CreateLoadBalancerHTTPListenerRequest::setBackendServerPort(int backendServerPort) {
+  backendServerPort_ = backendServerPort;
+  setParameter(std::string("BackendServerPort"), std::to_string(backendServerPort));
+}
+
 std::string CreateLoadBalancerHTTPListenerRequest::getDescription() const {
   return description_;
 }

ens/src/model/CreateLoadBalancerHTTPSListenerRequest.cc

@@ -124,6 +124,15 @@ void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckInterval(int healthCh
   setParameter(std::string("HealthCheckInterval"), std::to_string(healthCheckInterval));
 }
 
+int CreateLoadBalancerHTTPSListenerRequest::getBackendServerPort() const {
+  return backendServerPort_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setBackendServerPort(int backendServerPort) {
+  backendServerPort_ = backendServerPort;
+  setParameter(std::string("BackendServerPort"), std::to_string(backendServerPort));
+}
+
 std::string CreateLoadBalancerHTTPSListenerRequest::getDescription() const {
   return description_;
 }

ens/src/model/CreateLoadBalancerUDPListenerRequest.cc

@@ -34,6 +34,15 @@ void CreateLoadBalancerUDPListenerRequest::setProtocol(const std::string &protoc
   setParameter(std::string("Protocol"), protocol);
 }
 
+int CreateLoadBalancerUDPListenerRequest::getEstablishedTimeout() const {
+  return establishedTimeout_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setEstablishedTimeout(int establishedTimeout) {
+  establishedTimeout_ = establishedTimeout;
+  setParameter(std::string("EstablishedTimeout"), std::to_string(establishedTimeout));
+}
+
 std::string CreateLoadBalancerUDPListenerRequest::getLoadBalancerId() const {
   return loadBalancerId_;
 }

ens/src/model/CreateStorageGatewayRequest.cc

@@ -0,0 +1,42 @@
+/*
+ * 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/ens/model/CreateStorageGatewayRequest.h>
+
+using AlibabaCloud::Ens::Model::CreateStorageGatewayRequest;
+
+CreateStorageGatewayRequest::CreateStorageGatewayRequest()
+    : RpcServiceRequest("ens", "2017-11-10", "CreateStorageGateway") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateStorageGatewayRequest::~CreateStorageGatewayRequest() {}
+
+std::vector<CreateStorageGatewayRequest::OrderDetails> CreateStorageGatewayRequest::getOrderDetails() const {
+  return orderDetails_;
+}
+
+void CreateStorageGatewayRequest::setOrderDetails(const std::vector<CreateStorageGatewayRequest::OrderDetails> &orderDetails) {
+  orderDetails_ = orderDetails;
+  for(int dep1 = 0; dep1 != orderDetails.size(); dep1++) {
+    setParameter(std::string("OrderDetails") + "." + std::to_string(dep1 + 1) + ".GatewayType", orderDetails[dep1].gatewayType);
+    setParameter(std::string("OrderDetails") + "." + std::to_string(dep1 + 1) + ".VpcId", orderDetails[dep1].vpcId);
+    setParameter(std::string("OrderDetails") + "." + std::to_string(dep1 + 1) + ".GatewayName", orderDetails[dep1].gatewayName);
+    setParameter(std::string("OrderDetails") + "." + std::to_string(dep1 + 1) + ".EnsRegionId", orderDetails[dep1].ensRegionId);
+    setParameter(std::string("OrderDetails") + "." + std::to_string(dep1 + 1) + ".Description", orderDetails[dep1].description);
+  }
+}
+

ens/src/model/CreateStorageGatewayResult.cc

@@ -0,0 +1,81 @@
+/*
+ * 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/ens/model/CreateStorageGatewayResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ens;
+using namespace AlibabaCloud::Ens::Model;
+
+CreateStorageGatewayResult::CreateStorageGatewayResult() :
+	ServiceResult()
+{}
+
+CreateStorageGatewayResult::CreateStorageGatewayResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateStorageGatewayResult::~CreateStorageGatewayResult()
+{}
+
+void CreateStorageGatewayResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allAllocationIdNode = value["AllocationId"]["AllocationIdItem"];
+	for (auto valueAllocationIdAllocationIdItem : allAllocationIdNode)
+	{
+		AllocationIdItem allocationIdObject;
+		if(!valueAllocationIdAllocationIdItem["InstanceId"].isNull())
+			allocationIdObject.instanceId = valueAllocationIdAllocationIdItem["InstanceId"].asString();
+		if(!valueAllocationIdAllocationIdItem["EnsRegionId"].isNull())
+			allocationIdObject.ensRegionId = valueAllocationIdAllocationIdItem["EnsRegionId"].asString();
+		allocationId_.push_back(allocationIdObject);
+	}
+	auto allUnAllocationIdNode = value["UnAllocationId"]["UnAllocationIdItem"];
+	for (auto valueUnAllocationIdUnAllocationIdItem : allUnAllocationIdNode)
+	{
+		UnAllocationIdItem unAllocationIdObject;
+		if(!valueUnAllocationIdUnAllocationIdItem["InstanceId"].isNull())
+			unAllocationIdObject.instanceId = valueUnAllocationIdUnAllocationIdItem["InstanceId"].asString();
+		if(!valueUnAllocationIdUnAllocationIdItem["EnsRegionId"].isNull())
+			unAllocationIdObject.ensRegionId = valueUnAllocationIdUnAllocationIdItem["EnsRegionId"].asString();
+		unAllocationId_.push_back(unAllocationIdObject);
+	}
+	if(!value["BizStatusCode"].isNull())
+		bizStatusCode_ = value["BizStatusCode"].asString();
+
+}
+
+std::string CreateStorageGatewayResult::getBizStatusCode()const
+{
+	return bizStatusCode_;
+}
+
+std::vector<CreateStorageGatewayResult::AllocationIdItem> CreateStorageGatewayResult::getAllocationId()const
+{
+	return allocationId_;
+}
+
+std::vector<CreateStorageGatewayResult::UnAllocationIdItem> CreateStorageGatewayResult::getUnAllocationId()const
+{
+	return unAllocationId_;
+}
+

ens/src/model/CreateStorageVolumeRequest.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/ens/model/CreateStorageVolumeRequest.h>
+
+using AlibabaCloud::Ens::Model::CreateStorageVolumeRequest;
+
+CreateStorageVolumeRequest::CreateStorageVolumeRequest()
+    : RpcServiceRequest("ens", "2017-11-10", "CreateStorageVolume") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateStorageVolumeRequest::~CreateStorageVolumeRequest() {}
+
+std::string CreateStorageVolumeRequest::getEnsRegionId() const {
+  return ensRegionId_;
+}
+
+void CreateStorageVolumeRequest::setEnsRegionId(const std::string &ensRegionId) {
+  ensRegionId_ = ensRegionId;
+  setParameter(std::string("EnsRegionId"), ensRegionId);
+}
+
+std::string CreateStorageVolumeRequest::getGatewayId() const {
+  return gatewayId_;
+}
+
+void CreateStorageVolumeRequest::setGatewayId(const std::string &gatewayId) {
+  gatewayId_ = gatewayId;
+  setParameter(std::string("GatewayId"), gatewayId);
+}
+
+std::string CreateStorageVolumeRequest::getAuthUser() const {
+  return authUser_;
+}
+
+void CreateStorageVolumeRequest::setAuthUser(const std::string &authUser) {
+  authUser_ = authUser;
+  setParameter(std::string("AuthUser"), authUser);
+}
+
+std::string CreateStorageVolumeRequest::getVolumeName() const {
+  return volumeName_;
+}
+
+void CreateStorageVolumeRequest::setVolumeName(const std::string &volumeName) {
+  volumeName_ = volumeName;
+  setParameter(std::string("VolumeName"), volumeName);
+}
+
+std::string CreateStorageVolumeRequest::getAuthPassword() const {
+  return authPassword_;
+}
+
+void CreateStorageVolumeRequest::setAuthPassword(const std::string &authPassword) {
+  authPassword_ = authPassword;
+  setParameter(std::string("AuthPassword"), authPassword);
+}
+
+std::string CreateStorageVolumeRequest::getAuthProtocol() const {
+  return authProtocol_;
+}
+
+void CreateStorageVolumeRequest::setAuthProtocol(const std::string &authProtocol) {
+  authProtocol_ = authProtocol;
+  setParameter(std::string("AuthProtocol"), authProtocol);
+}
+
+std::string CreateStorageVolumeRequest::getDescription() const {
+  return description_;
+}
+
+void CreateStorageVolumeRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+std::string CreateStorageVolumeRequest::getIsEnable() const {
+  return isEnable_;
+}
+
+void CreateStorageVolumeRequest::setIsEnable(const std::string &isEnable) {
+  isEnable_ = isEnable;
+  setParameter(std::string("IsEnable"), isEnable);
+}
+
+std::string CreateStorageVolumeRequest::getIsAuth() const {
+  return isAuth_;
+}
+
+void CreateStorageVolumeRequest::setIsAuth(const std::string &isAuth) {
+  isAuth_ = isAuth;
+  setParameter(std::string("IsAuth"), isAuth);
+}
+
+std::string CreateStorageVolumeRequest::getStorageId() const {
+  return storageId_;
+}
+
+void CreateStorageVolumeRequest::setStorageId(const std::string &storageId) {
+  storageId_ = storageId;
+  setParameter(std::string("StorageId"), storageId);
+}
+

ens/src/model/CreateStorageVolumeResult.cc

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ens/model/CreateStorageVolumeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ens;
+using namespace AlibabaCloud::Ens::Model;
+
+CreateStorageVolumeResult::CreateStorageVolumeResult() :
+	ServiceResult()
+{}
+
+CreateStorageVolumeResult::CreateStorageVolumeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateStorageVolumeResult::~CreateStorageVolumeResult()
+{}
+
+void CreateStorageVolumeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allVolumeId = value["VolumeId"]["VolumeId"];
+	for (const auto &item : allVolumeId)
+		volumeId_.push_back(item.asString());
+
+}
+
+std::vector<std::string> CreateStorageVolumeResult::getVolumeId()const
+{
+	return volumeId_;
+}
+

ens/src/model/DeleteStorageGatewayRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * 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/ens/model/DeleteStorageGatewayRequest.h>
+
+using AlibabaCloud::Ens::Model::DeleteStorageGatewayRequest;
+
+DeleteStorageGatewayRequest::DeleteStorageGatewayRequest()
+    : RpcServiceRequest("ens", "2017-11-10", "DeleteStorageGateway") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteStorageGatewayRequest::~DeleteStorageGatewayRequest() {}
+
+std::string DeleteStorageGatewayRequest::getGatewayId() const {
+  return gatewayId_;
+}
+
+void DeleteStorageGatewayRequest::setGatewayId(const std::string &gatewayId) {
+  gatewayId_ = gatewayId;
+  setParameter(std::string("GatewayId"), gatewayId);
+}
+

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

ens/src/model/DeleteStorageVolumeRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * 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/ens/model/DeleteStorageVolumeRequest.h>
+
+using AlibabaCloud::Ens::Model::DeleteStorageVolumeRequest;
+
+DeleteStorageVolumeRequest::DeleteStorageVolumeRequest()
+    : RpcServiceRequest("ens", "2017-11-10", "DeleteStorageVolume") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteStorageVolumeRequest::~DeleteStorageVolumeRequest() {}
+
+std::string DeleteStorageVolumeRequest::getVolumeId() const {
+  return volumeId_;
+}
+
+void DeleteStorageVolumeRequest::setVolumeId(const std::string &volumeId) {
+  volumeId_ = volumeId;
+  setParameter(std::string("VolumeId"), volumeId);
+}
+

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

ens/src/model/DescribeInstancesResult.cc

@@ -105,6 +105,10 @@ void DescribeInstancesResult::parse(const std::string &payload)
 				dataDiskObject.name = valueInstancesInstanceDataDiskDataDiskItem["name"].asString();
 			if(!valueInstancesInstanceDataDiskDataDiskItem["DiskSize"].isNull())
 				dataDiskObject.diskSize = std::stoi(valueInstancesInstanceDataDiskDataDiskItem["DiskSize"].asString());
+			if(!valueInstancesInstanceDataDiskDataDiskItem["EncryptKeyId"].isNull())
+				dataDiskObject.encryptKeyId = valueInstancesInstanceDataDiskDataDiskItem["EncryptKeyId"].asString();
+			if(!valueInstancesInstanceDataDiskDataDiskItem["Encrypted"].isNull())
+				dataDiskObject.encrypted = valueInstancesInstanceDataDiskDataDiskItem["Encrypted"].asString() == "true";
 			instancesObject.dataDisk.push_back(dataDiskObject);
 		}
 		auto allPublicIpAddressesNode = valueInstancesInstance["PublicIpAddresses"]["PublicIpAddress"];

ens/src/model/DescribeLoadBalancerHTTPListenerAttributeResult.cc

@@ -89,6 +89,8 @@ void DescribeLoadBalancerHTTPListenerAttributeResult::parse(const std::string &p
 		healthCheckMethod_ = value["HealthCheckMethod"].asString();
 	if(!value["XForwardedFor"].isNull())
 		xForwardedFor_ = value["XForwardedFor"].asString();
+	if(!value["BackendServerPort"].isNull())
+		backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
 
 }
 
@@ -127,6 +129,11 @@ int DescribeLoadBalancerHTTPListenerAttributeResult::getIdleTimeout()const
 	return idleTimeout_;
 }
 
+int DescribeLoadBalancerHTTPListenerAttributeResult::getBackendServerPort()const
+{
+	return backendServerPort_;
+}
+
 int DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckConnectPort()const
 {
 	return healthCheckConnectPort_;

ens/src/model/DescribeLoadBalancerHTTPSListenerAttributeResult.cc

@@ -87,39 +87,16 @@ void DescribeLoadBalancerHTTPSListenerAttributeResult::parse(const std::string &
 		serverCertificateId_ = value["ServerCertificateId"].asString();
 	if(!value["HealthCheckMethod"].isNull())
 		healthCheckMethod_ = value["HealthCheckMethod"].asString();
+	if(!value["BackendServerPort"].isNull())
+		backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
 
 }
 
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStatus()const
-{
-	return status_;
-}
-
 int DescribeLoadBalancerHTTPSListenerAttributeResult::getCookieTimeout()const
 {
 	return cookieTimeout_;
 }
 
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getCookie()const
-{
-	return cookie_;
-}
-
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getListenerPort()const
-{
-	return listenerPort_;
-}
-
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getRequestTimeout()const
-{
-	return requestTimeout_;
-}
-
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckInterval()const
-{
-	return healthCheckInterval_;
-}
-
 std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getDescription()const
 {
 	return description_;
@@ -150,19 +127,9 @@ int DescribeLoadBalancerHTTPSListenerAttributeResult::getIdleTimeout()const
 	return idleTimeout_;
 }
 
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckTimeout()const
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getBackendServerPort()const
 {
-	return healthCheckTimeout_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getListenerForward()const
-{
-	return listenerForward_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStickySession()const
-{
-	return stickySession_;
+	return backendServerPort_;
 }
 
 int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckConnectPort()const
@@ -170,11 +137,6 @@ int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckConnectPort(
 	return healthCheckConnectPort_;
 }
 
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getForwardPort()const
-{
-	return forwardPort_;
-}
-
 std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckMethod()const
 {
 	return healthCheckMethod_;
@@ -185,16 +147,6 @@ int DescribeLoadBalancerHTTPSListenerAttributeResult::getBandwidth()const
 	return bandwidth_;
 }
 
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthyThreshold()const
-{
-	return healthyThreshold_;
-}
-
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckDomain()const
-{
-	return healthCheckDomain_;
-}
-
 std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getServerCertificateId()const
 {
 	return serverCertificateId_;
@@ -210,3 +162,58 @@ std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckHttp
 	return healthCheckHttpCode_;
 }
 
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStatus()const
+{
+	return status_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getCookie()const
+{
+	return cookie_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getListenerPort()const
+{
+	return listenerPort_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getRequestTimeout()const
+{
+	return requestTimeout_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckInterval()const
+{
+	return healthCheckInterval_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckTimeout()const
+{
+	return healthCheckTimeout_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getListenerForward()const
+{
+	return listenerForward_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStickySession()const
+{
+	return stickySession_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getForwardPort()const
+{
+	return forwardPort_;
+}
+
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthyThreshold()const
+{
+	return healthyThreshold_;
+}
+
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckDomain()const
+{
+	return healthCheckDomain_;
+}
+

ens/src/model/DescribeLoadBalancerUDPListenerAttributeResult.cc

@@ -69,6 +69,8 @@ void DescribeLoadBalancerUDPListenerAttributeResult::parse(const std::string &pa
 		healthCheckExp_ = value["HealthCheckExp"].asString();
 	if(!value["EipTransmit"].isNull())
 		eipTransmit_ = value["EipTransmit"].asString();
+	if(!value["EstablishedTimeout"].isNull())
+		establishedTimeout_ = std::stoi(value["EstablishedTimeout"].asString());
 
 }
 
@@ -147,3 +149,8 @@ std::string DescribeLoadBalancerUDPListenerAttributeResult::getEipTransmit()cons
 	return eipTransmit_;
 }
 
+int DescribeLoadBalancerUDPListenerAttributeResult::getEstablishedTimeout()const
+{
+	return establishedTimeout_;
+}
+

ens/src/model/DescribeSDGDeploymentStatusRequest.cc

@@ -20,18 +20,58 @@ using AlibabaCloud::Ens::Model::DescribeSDGDeploymentStatusRequest;
 
 DescribeSDGDeploymentStatusRequest::DescribeSDGDeploymentStatusRequest()
     : RpcServiceRequest("ens", "2017-11-10", "DescribeSDGDeploymentStatus") {
-  setMethod(HttpRequest::Method::Get);
+  setMethod(HttpRequest::Method::Post);
 }
 
 DescribeSDGDeploymentStatusRequest::~DescribeSDGDeploymentStatusRequest() {}
 
-std::string DescribeSDGDeploymentStatusRequest::getPageNumber() const {
+std::vector<DescribeSDGDeploymentStatusRequest::std::string> DescribeSDGDeploymentStatusRequest::getRegionIds() const {
+  return regionIds_;
+}
+
+void DescribeSDGDeploymentStatusRequest::setRegionIds(const std::vector<DescribeSDGDeploymentStatusRequest::std::string> &regionIds) {
+  regionIds_ = regionIds;
+  for(int dep1 = 0; dep1 != regionIds.size(); dep1++) {
+    setParameter(std::string("RegionIds") + "." + std::to_string(dep1 + 1), regionIds[dep1]);
+  }
+}
+
+std::vector<DescribeSDGDeploymentStatusRequest::std::string> DescribeSDGDeploymentStatusRequest::getInstanceIds() const {
+  return instanceIds_;
+}
+
+void DescribeSDGDeploymentStatusRequest::setInstanceIds(const std::vector<DescribeSDGDeploymentStatusRequest::std::string> &instanceIds) {
+  instanceIds_ = instanceIds;
+  for(int dep1 = 0; dep1 != instanceIds.size(); dep1++) {
+    setParameter(std::string("InstanceIds") + "." + std::to_string(dep1 + 1), instanceIds[dep1]);
+  }
+}
+
+std::string DescribeSDGDeploymentStatusRequest::getStatus() const {
+  return status_;
+}
+
+void DescribeSDGDeploymentStatusRequest::setStatus(const std::string &status) {
+  status_ = status;
+  setParameter(std::string("Status"), status);
+}
+
+std::string DescribeSDGDeploymentStatusRequest::getDeploymentType() const {
+  return deploymentType_;
+}
+
+void DescribeSDGDeploymentStatusRequest::setDeploymentType(const std::string &deploymentType) {
+  deploymentType_ = deploymentType;
+  setParameter(std::string("DeploymentType"), deploymentType);
+}
+
+int DescribeSDGDeploymentStatusRequest::getPageNumber() const {
   return pageNumber_;
 }
 
-void DescribeSDGDeploymentStatusRequest::setPageNumber(const std::string &pageNumber) {
+void DescribeSDGDeploymentStatusRequest::setPageNumber(int pageNumber) {
   pageNumber_ = pageNumber;
-  setParameter(std::string("PageNumber"), pageNumber);
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
 }
 
 std::string DescribeSDGDeploymentStatusRequest::getSDGId() const {
@@ -43,12 +83,12 @@ void DescribeSDGDeploymentStatusRequest::setSDGId(const std::string &sDGId) {
   setParameter(std::string("SDGId"), sDGId);
 }
 
-std::string DescribeSDGDeploymentStatusRequest::getPageSize() const {
+int DescribeSDGDeploymentStatusRequest::getPageSize() const {
   return pageSize_;
 }
 
-void DescribeSDGDeploymentStatusRequest::setPageSize(const std::string &pageSize) {
+void DescribeSDGDeploymentStatusRequest::setPageSize(int pageSize) {
   pageSize_ = pageSize;
-  setParameter(std::string("PageSize"), pageSize);
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 

ens/src/model/DescribeSelfImagesResult.cc

@@ -67,6 +67,8 @@ void DescribeSelfImagesResult::parse(const std::string &payload)
 			imagesObject.computeType = valueImagesImage["ComputeType"].asString();
 		if(!valueImagesImage["SnapshotId"].isNull())
 			imagesObject.snapshotId = valueImagesImage["SnapshotId"].asString();
+		if(!valueImagesImage["ImageStorageSize"].isNull())
+			imagesObject.imageStorageSize = valueImagesImage["ImageStorageSize"].asString();
 		images_.push_back(imagesObject);
 	}
 	if(!value["Code"].isNull())

ens/src/model/DescribeStorageGatewayRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * 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/ens/model/DescribeStorageGatewayRequest.h>
+
+using AlibabaCloud::Ens::Model::DescribeStorageGatewayRequest;
+
+DescribeStorageGatewayRequest::DescribeStorageGatewayRequest()
+    : RpcServiceRequest("ens", "2017-11-10", "DescribeStorageGateway") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeStorageGatewayRequest::~DescribeStorageGatewayRequest() {}
+
+std::string DescribeStorageGatewayRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeStorageGatewayRequest::setPageNumber(const std::string &pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), pageNumber);
+}
+
+std::string DescribeStorageGatewayRequest::getEnsRegionId() const {
+  return ensRegionId_;
+}
+
+void DescribeStorageGatewayRequest::setEnsRegionId(const std::string &ensRegionId) {
+  ensRegionId_ = ensRegionId;
+  setParameter(std::string("EnsRegionId"), ensRegionId);
+}
+
+std::string DescribeStorageGatewayRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeStorageGatewayRequest::setPageSize(const std::string &pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), pageSize);
+}
+
+std::string DescribeStorageGatewayRequest::getGatewayId() const {
+  return gatewayId_;
+}
+
+void DescribeStorageGatewayRequest::setGatewayId(const std::string &gatewayId) {
+  gatewayId_ = gatewayId;
+  setParameter(std::string("GatewayId"), gatewayId);
+}
+
+std::string DescribeStorageGatewayRequest::getGatewayType() const {
+  return gatewayType_;
+}
+
+void DescribeStorageGatewayRequest::setGatewayType(const std::string &gatewayType) {
+  gatewayType_ = gatewayType;
+  setParameter(std::string("GatewayType"), gatewayType);
+}
+
+std::string DescribeStorageGatewayRequest::getVpcId() const {
+  return vpcId_;
+}
+
+void DescribeStorageGatewayRequest::setVpcId(const std::string &vpcId) {
+  vpcId_ = vpcId;
+  setParameter(std::string("VpcId"), vpcId);
+}
+

ens/src/model/DescribeStorageGatewayResult.cc

@@ -0,0 +1,96 @@
+/*
+ * 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/ens/model/DescribeStorageGatewayResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ens;
+using namespace AlibabaCloud::Ens::Model;
+
+DescribeStorageGatewayResult::DescribeStorageGatewayResult() :
+	ServiceResult()
+{}
+
+DescribeStorageGatewayResult::DescribeStorageGatewayResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeStorageGatewayResult::~DescribeStorageGatewayResult()
+{}
+
+void DescribeStorageGatewayResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allStorageGatewaysNode = value["StorageGateways"]["StorageGatewaysItem"];
+	for (auto valueStorageGatewaysStorageGatewaysItem : allStorageGatewaysNode)
+	{
+		StorageGatewaysItem storageGatewaysObject;
+		if(!valueStorageGatewaysStorageGatewaysItem["EnsRegionId"].isNull())
+			storageGatewaysObject.ensRegionId = valueStorageGatewaysStorageGatewaysItem["EnsRegionId"].asString();
+		if(!valueStorageGatewaysStorageGatewaysItem["StorageGatewayId"].isNull())
+			storageGatewaysObject.storageGatewayId = valueStorageGatewaysStorageGatewaysItem["StorageGatewayId"].asString();
+		if(!valueStorageGatewaysStorageGatewaysItem["StorageGatewayName"].isNull())
+			storageGatewaysObject.storageGatewayName = valueStorageGatewaysStorageGatewaysItem["StorageGatewayName"].asString();
+		if(!valueStorageGatewaysStorageGatewaysItem["StorageGatewayType"].isNull())
+			storageGatewaysObject.storageGatewayType = std::stoi(valueStorageGatewaysStorageGatewaysItem["StorageGatewayType"].asString());
+		if(!valueStorageGatewaysStorageGatewaysItem["ServiceIp"].isNull())
+			storageGatewaysObject.serviceIp = valueStorageGatewaysStorageGatewaysItem["ServiceIp"].asString();
+		if(!valueStorageGatewaysStorageGatewaysItem["CreationTime"].isNull())
+			storageGatewaysObject.creationTime = valueStorageGatewaysStorageGatewaysItem["CreationTime"].asString();
+		if(!valueStorageGatewaysStorageGatewaysItem["Status"].isNull())
+			storageGatewaysObject.status = valueStorageGatewaysStorageGatewaysItem["Status"].asString();
+		if(!valueStorageGatewaysStorageGatewaysItem["Description"].isNull())
+			storageGatewaysObject.description = valueStorageGatewaysStorageGatewaysItem["Description"].asString();
+		if(!valueStorageGatewaysStorageGatewaysItem["VpcId"].isNull())
+			storageGatewaysObject.vpcId = valueStorageGatewaysStorageGatewaysItem["VpcId"].asString();
+		if(!valueStorageGatewaysStorageGatewaysItem["CidrBlock"].isNull())
+			storageGatewaysObject.cidrBlock = valueStorageGatewaysStorageGatewaysItem["CidrBlock"].asString();
+		storageGateways_.push_back(storageGatewaysObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+std::vector<DescribeStorageGatewayResult::StorageGatewaysItem> DescribeStorageGatewayResult::getStorageGateways()const
+{
+	return storageGateways_;
+}
+
+int DescribeStorageGatewayResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeStorageGatewayResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeStorageGatewayResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

ens/src/model/DescribeStorageVolumeRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ens/model/DescribeStorageVolumeRequest.h>
+
+using AlibabaCloud::Ens::Model::DescribeStorageVolumeRequest;
+
+DescribeStorageVolumeRequest::DescribeStorageVolumeRequest()
+    : RpcServiceRequest("ens", "2017-11-10", "DescribeStorageVolume") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeStorageVolumeRequest::~DescribeStorageVolumeRequest() {}
+
+std::string DescribeStorageVolumeRequest::getEnsRegionId() const {
+  return ensRegionId_;
+}
+
+void DescribeStorageVolumeRequest::setEnsRegionId(const std::string &ensRegionId) {
+  ensRegionId_ = ensRegionId;
+  setParameter(std::string("EnsRegionId"), ensRegionId);
+}
+
+std::string DescribeStorageVolumeRequest::getGatewayId() const {
+  return gatewayId_;
+}
+
+void DescribeStorageVolumeRequest::setGatewayId(const std::string &gatewayId) {
+  gatewayId_ = gatewayId;
+  setParameter(std::string("GatewayId"), gatewayId);
+}
+
+std::string DescribeStorageVolumeRequest::getVolumeId() const {
+  return volumeId_;
+}
+
+void DescribeStorageVolumeRequest::setVolumeId(const std::string &volumeId) {
+  volumeId_ = volumeId;
+  setParameter(std::string("VolumeId"), volumeId);
+}
+
+int DescribeStorageVolumeRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeStorageVolumeRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+int DescribeStorageVolumeRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeStorageVolumeRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+int DescribeStorageVolumeRequest::getIsEnable() const {
+  return isEnable_;
+}
+
+void DescribeStorageVolumeRequest::setIsEnable(int isEnable) {
+  isEnable_ = isEnable;
+  setParameter(std::string("IsEnable"), std::to_string(isEnable));
+}
+
+std::string DescribeStorageVolumeRequest::getStorageId() const {
+  return storageId_;
+}
+
+void DescribeStorageVolumeRequest::setStorageId(const std::string &storageId) {
+  storageId_ = storageId;
+  setParameter(std::string("StorageId"), storageId);
+}
+

ens/src/model/DescribeStorageVolumeResult.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/ens/model/DescribeStorageVolumeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ens;
+using namespace AlibabaCloud::Ens::Model;
+
+DescribeStorageVolumeResult::DescribeStorageVolumeResult() :
+	ServiceResult()
+{}
+
+DescribeStorageVolumeResult::DescribeStorageVolumeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeStorageVolumeResult::~DescribeStorageVolumeResult()
+{}
+
+void DescribeStorageVolumeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allStorageVolumesNode = value["StorageVolumes"]["StorageVolumesItem"];
+	for (auto valueStorageVolumesStorageVolumesItem : allStorageVolumesNode)
+	{
+		StorageVolumesItem storageVolumesObject;
+		if(!valueStorageVolumesStorageVolumesItem["StorageVolumeId"].isNull())
+			storageVolumesObject.storageVolumeId = valueStorageVolumesStorageVolumesItem["StorageVolumeId"].asString();
+		if(!valueStorageVolumesStorageVolumesItem["StorageVolumeName"].isNull())
+			storageVolumesObject.storageVolumeName = valueStorageVolumesStorageVolumesItem["StorageVolumeName"].asString();
+		if(!valueStorageVolumesStorageVolumesItem["StorageGatewayId"].isNull())
+			storageVolumesObject.storageGatewayId = valueStorageVolumesStorageVolumesItem["StorageGatewayId"].asString();
+		if(!valueStorageVolumesStorageVolumesItem["StorageId"].isNull())
+			storageVolumesObject.storageId = valueStorageVolumesStorageVolumesItem["StorageId"].asString();
+		if(!valueStorageVolumesStorageVolumesItem["CreationTime"].isNull())
+			storageVolumesObject.creationTime = valueStorageVolumesStorageVolumesItem["CreationTime"].asString();
+		if(!valueStorageVolumesStorageVolumesItem["IsEnable"].isNull())
+			storageVolumesObject.isEnable = std::stoi(valueStorageVolumesStorageVolumesItem["IsEnable"].asString());
+		if(!valueStorageVolumesStorageVolumesItem["IsAuth"].isNull())
+			storageVolumesObject.isAuth = std::stoi(valueStorageVolumesStorageVolumesItem["IsAuth"].asString());
+		if(!valueStorageVolumesStorageVolumesItem["Description"].isNull())
+			storageVolumesObject.description = valueStorageVolumesStorageVolumesItem["Description"].asString();
+		if(!valueStorageVolumesStorageVolumesItem["TargetName"].isNull())
+			storageVolumesObject.targetName = valueStorageVolumesStorageVolumesItem["TargetName"].asString();
+		if(!valueStorageVolumesStorageVolumesItem["Status"].isNull())
+			storageVolumesObject.status = valueStorageVolumesStorageVolumesItem["Status"].asString();
+		if(!valueStorageVolumesStorageVolumesItem["AuthProtocol"].isNull())
+			storageVolumesObject.authProtocol = valueStorageVolumesStorageVolumesItem["AuthProtocol"].asString();
+		if(!valueStorageVolumesStorageVolumesItem["EnsRegionId"].isNull())
+			storageVolumesObject.ensRegionId = valueStorageVolumesStorageVolumesItem["EnsRegionId"].asString();
+		storageVolumes_.push_back(storageVolumesObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = value["PageNumber"].asString();
+	if(!value["PageSize"].isNull())
+		pageSize_ = value["PageSize"].asString();
+	if(!value["TotalCount"].isNull())
+		totalCount_ = value["TotalCount"].asString();
+
+}
+
+std::string DescribeStorageVolumeResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::string DescribeStorageVolumeResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+std::string DescribeStorageVolumeResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeStorageVolumeResult::StorageVolumesItem> DescribeStorageVolumeResult::getStorageVolumes()const
+{
+	return storageVolumes_;
+}
+

ens/src/model/PrepareUploadRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ens/model/PrepareUploadRequest.h>
+
+using AlibabaCloud::Ens::Model::PrepareUploadRequest;
+
+PrepareUploadRequest::PrepareUploadRequest()
+    : RpcServiceRequest("ens", "2017-11-10", "PrepareUpload") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+PrepareUploadRequest::~PrepareUploadRequest() {}
+
+std::string PrepareUploadRequest::getClientIp() const {
+  return clientIp_;
+}
+
+void PrepareUploadRequest::setClientIp(const std::string &clientIp) {
+  clientIp_ = clientIp;
+  setParameter(std::string("ClientIp"), clientIp);
+}
+
+std::string PrepareUploadRequest::getEnsRegionId() const {
+  return ensRegionId_;
+}
+
+void PrepareUploadRequest::setEnsRegionId(const std::string &ensRegionId) {
+  ensRegionId_ = ensRegionId;
+  setParameter(std::string("EnsRegionId"), ensRegionId);
+}
+
+std::string PrepareUploadRequest::getAdditionType() const {
+  return additionType_;
+}
+
+void PrepareUploadRequest::setAdditionType(const std::string &additionType) {
+  additionType_ = additionType;
+  setParameter(std::string("AdditionType"), additionType);
+}
+
+std::string PrepareUploadRequest::getBucketName() const {
+  return bucketName_;
+}
+
+void PrepareUploadRequest::setBucketName(const std::string &bucketName) {
+  bucketName_ = bucketName;
+  setParameter(std::string("BucketName"), bucketName);
+}
+
+std::string PrepareUploadRequest::getStation() const {
+  return station_;
+}
+
+void PrepareUploadRequest::setStation(const std::string &station) {
+  station_ = station;
+  setParameter(std::string("Station"), station);
+}
+
+std::string PrepareUploadRequest::getObjectKey() const {
+  return objectKey_;
+}
+
+void PrepareUploadRequest::setObjectKey(const std::string &objectKey) {
+  objectKey_ = objectKey;
+  setParameter(std::string("ObjectKey"), objectKey);
+}
+
+long PrepareUploadRequest::getStorageCost() const {
+  return storageCost_;
+}
+
+void PrepareUploadRequest::setStorageCost(long storageCost) {
+  storageCost_ = storageCost;
+  setParameter(std::string("StorageCost"), std::to_string(storageCost));
+}
+

ens/src/model/PrepareUploadResult.cc

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ens/model/PrepareUploadResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ens;
+using namespace AlibabaCloud::Ens::Model;
+
+PrepareUploadResult::PrepareUploadResult() :
+	ServiceResult()
+{}
+
+PrepareUploadResult::PrepareUploadResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+PrepareUploadResult::~PrepareUploadResult()
+{}
+
+void PrepareUploadResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["BucketName"].isNull())
+		bucketName_ = value["BucketName"].asString();
+	if(!value["Endpoint"].isNull())
+		endpoint_ = value["Endpoint"].asString();
+	if(!value["AdditionInfo"].isNull())
+		additionInfo_ = value["AdditionInfo"].asString();
+
+}
+
+std::string PrepareUploadResult::getBucketName()const
+{
+	return bucketName_;
+}
+
+std::string PrepareUploadResult::getEndpoint()const
+{
+	return endpoint_;
+}
+
+std::string PrepareUploadResult::getAdditionInfo()const
+{
+	return additionInfo_;
+}
+

ens/src/model/PutBucketLifecycleResult.cc

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

ens/src/model/SetLoadBalancerUDPListenerAttributeRequest.cc

@@ -34,6 +34,15 @@ void SetLoadBalancerUDPListenerAttributeRequest::setProtocol(const std::string &
   setParameter(std::string("Protocol"), protocol);
 }
 
+int SetLoadBalancerUDPListenerAttributeRequest::getEstablishedTimeout() const {
+  return establishedTimeout_;
+}
+
+void SetLoadBalancerUDPListenerAttributeRequest::setEstablishedTimeout(int establishedTimeout) {
+  establishedTimeout_ = establishedTimeout;
+  setParameter(std::string("EstablishedTimeout"), std::to_string(establishedTimeout));
+}
+
 std::string SetLoadBalancerUDPListenerAttributeRequest::getLoadBalancerId() const {
   return loadBalancerId_;
 }