Generated 2017-11-10 for Ens.

VERSION

@@ -1 +1 @@
-1.36.1977
+1.36.1978

ens/CMakeLists.txt

@@ -107,6 +107,10 @@ set(ens_public_header_model
 	include/alibabacloud/ens/model/CreateSnapshotResult.h
 	include/alibabacloud/ens/model/CreateSnatEntryRequest.h
 	include/alibabacloud/ens/model/CreateSnatEntryResult.h
+	include/alibabacloud/ens/model/CreateStorageGatewayRequest.h
+	include/alibabacloud/ens/model/CreateStorageGatewayResult.h
+	include/alibabacloud/ens/model/CreateStorageVolumeRequest.h
+	include/alibabacloud/ens/model/CreateStorageVolumeResult.h
 	include/alibabacloud/ens/model/CreateVSwitchRequest.h
 	include/alibabacloud/ens/model/CreateVSwitchResult.h
 	include/alibabacloud/ens/model/DeleteApplicationRequest.h
@@ -159,6 +163,10 @@ set(ens_public_header_model
 	include/alibabacloud/ens/model/DeleteSnatEntryResult.h
 	include/alibabacloud/ens/model/DeleteSnatIpForSnatEntryRequest.h
 	include/alibabacloud/ens/model/DeleteSnatIpForSnatEntryResult.h
+	include/alibabacloud/ens/model/DeleteStorageGatewayRequest.h
+	include/alibabacloud/ens/model/DeleteStorageGatewayResult.h
+	include/alibabacloud/ens/model/DeleteStorageVolumeRequest.h
+	include/alibabacloud/ens/model/DeleteStorageVolumeResult.h
 	include/alibabacloud/ens/model/DeleteVSwitchRequest.h
 	include/alibabacloud/ens/model/DeleteVSwitchResult.h
 	include/alibabacloud/ens/model/DeployInstanceSDGRequest.h
@@ -329,6 +337,10 @@ set(ens_public_header_model
 	include/alibabacloud/ens/model/DescribeSnatAttributeResult.h
 	include/alibabacloud/ens/model/DescribeSnatTableEntriesRequest.h
 	include/alibabacloud/ens/model/DescribeSnatTableEntriesResult.h
+	include/alibabacloud/ens/model/DescribeStorageGatewayRequest.h
+	include/alibabacloud/ens/model/DescribeStorageGatewayResult.h
+	include/alibabacloud/ens/model/DescribeStorageVolumeRequest.h
+	include/alibabacloud/ens/model/DescribeStorageVolumeResult.h
 	include/alibabacloud/ens/model/DescribeUserBandWidthDataRequest.h
 	include/alibabacloud/ens/model/DescribeUserBandWidthDataResult.h
 	include/alibabacloud/ens/model/DescribeVSwitchesRequest.h
@@ -405,6 +417,8 @@ set(ens_public_header_model
 	include/alibabacloud/ens/model/ModifyVSwitchAttributeResult.h
 	include/alibabacloud/ens/model/PreloadRegionSDGRequest.h
 	include/alibabacloud/ens/model/PreloadRegionSDGResult.h
+	include/alibabacloud/ens/model/PrepareUploadRequest.h
+	include/alibabacloud/ens/model/PrepareUploadResult.h
 	include/alibabacloud/ens/model/PushApplicationDataRequest.h
 	include/alibabacloud/ens/model/PushApplicationDataResult.h
 	include/alibabacloud/ens/model/PutBucketRequest.h
@@ -618,6 +632,10 @@ set(ens_src
 	src/model/CreateSnapshotResult.cc
 	src/model/CreateSnatEntryRequest.cc
 	src/model/CreateSnatEntryResult.cc
+	src/model/CreateStorageGatewayRequest.cc
+	src/model/CreateStorageGatewayResult.cc
+	src/model/CreateStorageVolumeRequest.cc
+	src/model/CreateStorageVolumeResult.cc
 	src/model/CreateVSwitchRequest.cc
 	src/model/CreateVSwitchResult.cc
 	src/model/DeleteApplicationRequest.cc
@@ -670,6 +688,10 @@ set(ens_src
 	src/model/DeleteSnatEntryResult.cc
 	src/model/DeleteSnatIpForSnatEntryRequest.cc
 	src/model/DeleteSnatIpForSnatEntryResult.cc
+	src/model/DeleteStorageGatewayRequest.cc
+	src/model/DeleteStorageGatewayResult.cc
+	src/model/DeleteStorageVolumeRequest.cc
+	src/model/DeleteStorageVolumeResult.cc
 	src/model/DeleteVSwitchRequest.cc
 	src/model/DeleteVSwitchResult.cc
 	src/model/DeployInstanceSDGRequest.cc
@@ -840,6 +862,10 @@ set(ens_src
 	src/model/DescribeSnatAttributeResult.cc
 	src/model/DescribeSnatTableEntriesRequest.cc
 	src/model/DescribeSnatTableEntriesResult.cc
+	src/model/DescribeStorageGatewayRequest.cc
+	src/model/DescribeStorageGatewayResult.cc
+	src/model/DescribeStorageVolumeRequest.cc
+	src/model/DescribeStorageVolumeResult.cc
 	src/model/DescribeUserBandWidthDataRequest.cc
 	src/model/DescribeUserBandWidthDataResult.cc
 	src/model/DescribeVSwitchesRequest.cc
@@ -916,6 +942,8 @@ set(ens_src
 	src/model/ModifyVSwitchAttributeResult.cc
 	src/model/PreloadRegionSDGRequest.cc
 	src/model/PreloadRegionSDGResult.cc
+	src/model/PrepareUploadRequest.cc
+	src/model/PrepareUploadResult.cc
 	src/model/PushApplicationDataRequest.cc
 	src/model/PushApplicationDataResult.cc
 	src/model/PutBucketRequest.cc

ens/include/alibabacloud/ens/EnsClient.h

@@ -108,6 +108,10 @@
 #include "model/CreateSnapshotResult.h"
 #include "model/CreateSnatEntryRequest.h"
 #include "model/CreateSnatEntryResult.h"
+#include "model/CreateStorageGatewayRequest.h"
+#include "model/CreateStorageGatewayResult.h"
+#include "model/CreateStorageVolumeRequest.h"
+#include "model/CreateStorageVolumeResult.h"
 #include "model/CreateVSwitchRequest.h"
 #include "model/CreateVSwitchResult.h"
 #include "model/DeleteApplicationRequest.h"
@@ -160,6 +164,10 @@
 #include "model/DeleteSnatEntryResult.h"
 #include "model/DeleteSnatIpForSnatEntryRequest.h"
 #include "model/DeleteSnatIpForSnatEntryResult.h"
+#include "model/DeleteStorageGatewayRequest.h"
+#include "model/DeleteStorageGatewayResult.h"
+#include "model/DeleteStorageVolumeRequest.h"
+#include "model/DeleteStorageVolumeResult.h"
 #include "model/DeleteVSwitchRequest.h"
 #include "model/DeleteVSwitchResult.h"
 #include "model/DeployInstanceSDGRequest.h"
@@ -330,6 +338,10 @@
 #include "model/DescribeSnatAttributeResult.h"
 #include "model/DescribeSnatTableEntriesRequest.h"
 #include "model/DescribeSnatTableEntriesResult.h"
+#include "model/DescribeStorageGatewayRequest.h"
+#include "model/DescribeStorageGatewayResult.h"
+#include "model/DescribeStorageVolumeRequest.h"
+#include "model/DescribeStorageVolumeResult.h"
 #include "model/DescribeUserBandWidthDataRequest.h"
 #include "model/DescribeUserBandWidthDataResult.h"
 #include "model/DescribeVSwitchesRequest.h"
@@ -406,6 +418,8 @@
 #include "model/ModifyVSwitchAttributeResult.h"
 #include "model/PreloadRegionSDGRequest.h"
 #include "model/PreloadRegionSDGResult.h"
+#include "model/PrepareUploadRequest.h"
+#include "model/PrepareUploadResult.h"
 #include "model/PushApplicationDataRequest.h"
 #include "model/PushApplicationDataResult.h"
 #include "model/PutBucketRequest.h"
@@ -668,6 +682,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateSnatEntryResult> CreateSnatEntryOutcome;
 			typedef std::future<CreateSnatEntryOutcome> CreateSnatEntryOutcomeCallable;
 			typedef std::function<void(const EnsClient*, const Model::CreateSnatEntryRequest&, const CreateSnatEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateSnatEntryAsyncHandler;
+			typedef Outcome<Error, Model::CreateStorageGatewayResult> CreateStorageGatewayOutcome;
+			typedef std::future<CreateStorageGatewayOutcome> CreateStorageGatewayOutcomeCallable;
+			typedef std::function<void(const EnsClient*, const Model::CreateStorageGatewayRequest&, const CreateStorageGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateStorageGatewayAsyncHandler;
+			typedef Outcome<Error, Model::CreateStorageVolumeResult> CreateStorageVolumeOutcome;
+			typedef std::future<CreateStorageVolumeOutcome> CreateStorageVolumeOutcomeCallable;
+			typedef std::function<void(const EnsClient*, const Model::CreateStorageVolumeRequest&, const CreateStorageVolumeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateStorageVolumeAsyncHandler;
 			typedef Outcome<Error, Model::CreateVSwitchResult> CreateVSwitchOutcome;
 			typedef std::future<CreateVSwitchOutcome> CreateVSwitchOutcomeCallable;
 			typedef std::function<void(const EnsClient*, const Model::CreateVSwitchRequest&, const CreateVSwitchOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVSwitchAsyncHandler;
@@ -746,6 +766,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteSnatIpForSnatEntryResult> DeleteSnatIpForSnatEntryOutcome;
 			typedef std::future<DeleteSnatIpForSnatEntryOutcome> DeleteSnatIpForSnatEntryOutcomeCallable;
 			typedef std::function<void(const EnsClient*, const Model::DeleteSnatIpForSnatEntryRequest&, const DeleteSnatIpForSnatEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSnatIpForSnatEntryAsyncHandler;
+			typedef Outcome<Error, Model::DeleteStorageGatewayResult> DeleteStorageGatewayOutcome;
+			typedef std::future<DeleteStorageGatewayOutcome> DeleteStorageGatewayOutcomeCallable;
+			typedef std::function<void(const EnsClient*, const Model::DeleteStorageGatewayRequest&, const DeleteStorageGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteStorageGatewayAsyncHandler;
+			typedef Outcome<Error, Model::DeleteStorageVolumeResult> DeleteStorageVolumeOutcome;
+			typedef std::future<DeleteStorageVolumeOutcome> DeleteStorageVolumeOutcomeCallable;
+			typedef std::function<void(const EnsClient*, const Model::DeleteStorageVolumeRequest&, const DeleteStorageVolumeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteStorageVolumeAsyncHandler;
 			typedef Outcome<Error, Model::DeleteVSwitchResult> DeleteVSwitchOutcome;
 			typedef std::future<DeleteVSwitchOutcome> DeleteVSwitchOutcomeCallable;
 			typedef std::function<void(const EnsClient*, const Model::DeleteVSwitchRequest&, const DeleteVSwitchOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVSwitchAsyncHandler;
@@ -1001,6 +1027,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeSnatTableEntriesResult> DescribeSnatTableEntriesOutcome;
 			typedef std::future<DescribeSnatTableEntriesOutcome> DescribeSnatTableEntriesOutcomeCallable;
 			typedef std::function<void(const EnsClient*, const Model::DescribeSnatTableEntriesRequest&, const DescribeSnatTableEntriesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSnatTableEntriesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeStorageGatewayResult> DescribeStorageGatewayOutcome;
+			typedef std::future<DescribeStorageGatewayOutcome> DescribeStorageGatewayOutcomeCallable;
+			typedef std::function<void(const EnsClient*, const Model::DescribeStorageGatewayRequest&, const DescribeStorageGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeStorageGatewayAsyncHandler;
+			typedef Outcome<Error, Model::DescribeStorageVolumeResult> DescribeStorageVolumeOutcome;
+			typedef std::future<DescribeStorageVolumeOutcome> DescribeStorageVolumeOutcomeCallable;
+			typedef std::function<void(const EnsClient*, const Model::DescribeStorageVolumeRequest&, const DescribeStorageVolumeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeStorageVolumeAsyncHandler;
 			typedef Outcome<Error, Model::DescribeUserBandWidthDataResult> DescribeUserBandWidthDataOutcome;
 			typedef std::future<DescribeUserBandWidthDataOutcome> DescribeUserBandWidthDataOutcomeCallable;
 			typedef std::function<void(const EnsClient*, const Model::DescribeUserBandWidthDataRequest&, const DescribeUserBandWidthDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeUserBandWidthDataAsyncHandler;
@@ -1115,6 +1147,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::PreloadRegionSDGResult> PreloadRegionSDGOutcome;
 			typedef std::future<PreloadRegionSDGOutcome> PreloadRegionSDGOutcomeCallable;
 			typedef std::function<void(const EnsClient*, const Model::PreloadRegionSDGRequest&, const PreloadRegionSDGOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PreloadRegionSDGAsyncHandler;
+			typedef Outcome<Error, Model::PrepareUploadResult> PrepareUploadOutcome;
+			typedef std::future<PrepareUploadOutcome> PrepareUploadOutcomeCallable;
+			typedef std::function<void(const EnsClient*, const Model::PrepareUploadRequest&, const PrepareUploadOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PrepareUploadAsyncHandler;
 			typedef Outcome<Error, Model::PushApplicationDataResult> PushApplicationDataOutcome;
 			typedef std::future<PushApplicationDataOutcome> PushApplicationDataOutcomeCallable;
 			typedef std::function<void(const EnsClient*, const Model::PushApplicationDataRequest&, const PushApplicationDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PushApplicationDataAsyncHandler;
@@ -1435,6 +1470,12 @@ namespace AlibabaCloud
 			CreateSnatEntryOutcome createSnatEntry(const Model::CreateSnatEntryRequest &request)const;
 			void createSnatEntryAsync(const Model::CreateSnatEntryRequest& request, const CreateSnatEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateSnatEntryOutcomeCallable createSnatEntryCallable(const Model::CreateSnatEntryRequest& request) const;
+			CreateStorageGatewayOutcome createStorageGateway(const Model::CreateStorageGatewayRequest &request)const;
+			void createStorageGatewayAsync(const Model::CreateStorageGatewayRequest& request, const CreateStorageGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateStorageGatewayOutcomeCallable createStorageGatewayCallable(const Model::CreateStorageGatewayRequest& request) const;
+			CreateStorageVolumeOutcome createStorageVolume(const Model::CreateStorageVolumeRequest &request)const;
+			void createStorageVolumeAsync(const Model::CreateStorageVolumeRequest& request, const CreateStorageVolumeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateStorageVolumeOutcomeCallable createStorageVolumeCallable(const Model::CreateStorageVolumeRequest& request) const;
 			CreateVSwitchOutcome createVSwitch(const Model::CreateVSwitchRequest &request)const;
 			void createVSwitchAsync(const Model::CreateVSwitchRequest& request, const CreateVSwitchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateVSwitchOutcomeCallable createVSwitchCallable(const Model::CreateVSwitchRequest& request) const;
@@ -1513,6 +1554,12 @@ namespace AlibabaCloud
 			DeleteSnatIpForSnatEntryOutcome deleteSnatIpForSnatEntry(const Model::DeleteSnatIpForSnatEntryRequest &request)const;
 			void deleteSnatIpForSnatEntryAsync(const Model::DeleteSnatIpForSnatEntryRequest& request, const DeleteSnatIpForSnatEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteSnatIpForSnatEntryOutcomeCallable deleteSnatIpForSnatEntryCallable(const Model::DeleteSnatIpForSnatEntryRequest& request) const;
+			DeleteStorageGatewayOutcome deleteStorageGateway(const Model::DeleteStorageGatewayRequest &request)const;
+			void deleteStorageGatewayAsync(const Model::DeleteStorageGatewayRequest& request, const DeleteStorageGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteStorageGatewayOutcomeCallable deleteStorageGatewayCallable(const Model::DeleteStorageGatewayRequest& request) const;
+			DeleteStorageVolumeOutcome deleteStorageVolume(const Model::DeleteStorageVolumeRequest &request)const;
+			void deleteStorageVolumeAsync(const Model::DeleteStorageVolumeRequest& request, const DeleteStorageVolumeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteStorageVolumeOutcomeCallable deleteStorageVolumeCallable(const Model::DeleteStorageVolumeRequest& request) const;
 			DeleteVSwitchOutcome deleteVSwitch(const Model::DeleteVSwitchRequest &request)const;
 			void deleteVSwitchAsync(const Model::DeleteVSwitchRequest& request, const DeleteVSwitchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteVSwitchOutcomeCallable deleteVSwitchCallable(const Model::DeleteVSwitchRequest& request) const;
@@ -1768,6 +1815,12 @@ namespace AlibabaCloud
 			DescribeSnatTableEntriesOutcome describeSnatTableEntries(const Model::DescribeSnatTableEntriesRequest &request)const;
 			void describeSnatTableEntriesAsync(const Model::DescribeSnatTableEntriesRequest& request, const DescribeSnatTableEntriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeSnatTableEntriesOutcomeCallable describeSnatTableEntriesCallable(const Model::DescribeSnatTableEntriesRequest& request) const;
+			DescribeStorageGatewayOutcome describeStorageGateway(const Model::DescribeStorageGatewayRequest &request)const;
+			void describeStorageGatewayAsync(const Model::DescribeStorageGatewayRequest& request, const DescribeStorageGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeStorageGatewayOutcomeCallable describeStorageGatewayCallable(const Model::DescribeStorageGatewayRequest& request) const;
+			DescribeStorageVolumeOutcome describeStorageVolume(const Model::DescribeStorageVolumeRequest &request)const;
+			void describeStorageVolumeAsync(const Model::DescribeStorageVolumeRequest& request, const DescribeStorageVolumeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeStorageVolumeOutcomeCallable describeStorageVolumeCallable(const Model::DescribeStorageVolumeRequest& request) const;
 			DescribeUserBandWidthDataOutcome describeUserBandWidthData(const Model::DescribeUserBandWidthDataRequest &request)const;
 			void describeUserBandWidthDataAsync(const Model::DescribeUserBandWidthDataRequest& request, const DescribeUserBandWidthDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeUserBandWidthDataOutcomeCallable describeUserBandWidthDataCallable(const Model::DescribeUserBandWidthDataRequest& request) const;
@@ -1882,6 +1935,9 @@ namespace AlibabaCloud
 			PreloadRegionSDGOutcome preloadRegionSDG(const Model::PreloadRegionSDGRequest &request)const;
 			void preloadRegionSDGAsync(const Model::PreloadRegionSDGRequest& request, const PreloadRegionSDGAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			PreloadRegionSDGOutcomeCallable preloadRegionSDGCallable(const Model::PreloadRegionSDGRequest& request) const;
+			PrepareUploadOutcome prepareUpload(const Model::PrepareUploadRequest &request)const;
+			void prepareUploadAsync(const Model::PrepareUploadRequest& request, const PrepareUploadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PrepareUploadOutcomeCallable prepareUploadCallable(const Model::PrepareUploadRequest& request) const;
 			PushApplicationDataOutcome pushApplicationData(const Model::PushApplicationDataRequest &request)const;
 			void pushApplicationDataAsync(const Model::PushApplicationDataRequest& request, const PushApplicationDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			PushApplicationDataOutcomeCallable pushApplicationDataCallable(const Model::PushApplicationDataRequest& request) const;

ens/include/alibabacloud/ens/model/CreateLoadBalancerHTTPListenerRequest.h

@@ -54,6 +54,8 @@ public:
 	void setLoadBalancerId(const std::string &loadBalancerId);
 	int getHealthCheckInterval() const;
 	void setHealthCheckInterval(int healthCheckInterval);
+	int getBackendServerPort() const;
+	void setBackendServerPort(int backendServerPort);
 	std::string getDescription() const;
 	void setDescription(const std::string &description);
 	int getUnhealthyThreshold() const;
@@ -92,6 +94,7 @@ private:
 	int requestTimeout_;
 	std::string loadBalancerId_;
 	int healthCheckInterval_;
+	int backendServerPort_;
 	std::string description_;
 	int unhealthyThreshold_;
 	int healthyThreshold_;

ens/include/alibabacloud/ens/model/CreateLoadBalancerHTTPSListenerRequest.h

@@ -52,6 +52,8 @@ public:
 	void setLoadBalancerId(const std::string &loadBalancerId);
 	int getHealthCheckInterval() const;
 	void setHealthCheckInterval(int healthCheckInterval);
+	int getBackendServerPort() const;
+	void setBackendServerPort(int backendServerPort);
 	std::string getDescription() const;
 	void setDescription(const std::string &description);
 	int getUnhealthyThreshold() const;
@@ -91,6 +93,7 @@ private:
 	int requestTimeout_;
 	std::string loadBalancerId_;
 	int healthCheckInterval_;
+	int backendServerPort_;
 	std::string description_;
 	int unhealthyThreshold_;
 	int healthyThreshold_;

ens/include/alibabacloud/ens/model/CreateLoadBalancerUDPListenerRequest.h

@@ -32,6 +32,8 @@ public:
 	~CreateLoadBalancerUDPListenerRequest();
 	std::string getProtocol() const;
 	void setProtocol(const std::string &protocol);
+	int getEstablishedTimeout() const;
+	void setEstablishedTimeout(int establishedTimeout);
 	std::string getLoadBalancerId() const;
 	void setLoadBalancerId(const std::string &loadBalancerId);
 	std::string getHealthCheckReq() const;
@@ -61,6 +63,7 @@ public:
 
 private:
 	std::string protocol_;
+	int establishedTimeout_;
 	std::string loadBalancerId_;
 	std::string healthCheckReq_;
 	int healthCheckInterval_;

ens/include/alibabacloud/ens/model/CreateStorageGatewayRequest.h

@@ -0,0 +1,49 @@
+/*
+ * 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.
+ */
+
+#ifndef ALIBABACLOUD_ENS_MODEL_CREATESTORAGEGATEWAYREQUEST_H_
+#define ALIBABACLOUD_ENS_MODEL_CREATESTORAGEGATEWAYREQUEST_H_
+
+#include <alibabacloud/ens/EnsExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ens {
+namespace Model {
+class ALIBABACLOUD_ENS_EXPORT CreateStorageGatewayRequest : public RpcServiceRequest {
+public:
+	struct OrderDetails {
+		std::string gatewayType;
+		std::string vpcId;
+		std::string gatewayName;
+		std::string ensRegionId;
+		std::string description;
+	};
+	CreateStorageGatewayRequest();
+	~CreateStorageGatewayRequest();
+	std::vector<OrderDetails> getOrderDetails() const;
+	void setOrderDetails(const std::vector<OrderDetails> &orderDetails);
+
+private:
+	std::vector<OrderDetails> orderDetails_;
+};
+} // namespace Model
+} // namespace Ens
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ENS_MODEL_CREATESTORAGEGATEWAYREQUEST_H_

ens/include/alibabacloud/ens/model/CreateStorageGatewayResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_ENS_MODEL_CREATESTORAGEGATEWAYRESULT_H_
+#define ALIBABACLOUD_ENS_MODEL_CREATESTORAGEGATEWAYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ens/EnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ens
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ENS_EXPORT CreateStorageGatewayResult : public ServiceResult
+			{
+			public:
+				struct AllocationIdItem
+				{
+					std::string instanceId;
+					std::string ensRegionId;
+				};
+				struct UnAllocationIdItem
+				{
+					std::string instanceId;
+					std::string ensRegionId;
+				};
+
+
+				CreateStorageGatewayResult();
+				explicit CreateStorageGatewayResult(const std::string &payload);
+				~CreateStorageGatewayResult();
+				std::string getBizStatusCode()const;
+				std::vector<AllocationIdItem> getAllocationId()const;
+				std::vector<UnAllocationIdItem> getUnAllocationId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string bizStatusCode_;
+				std::vector<AllocationIdItem> allocationId_;
+				std::vector<UnAllocationIdItem> unAllocationId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ENS_MODEL_CREATESTORAGEGATEWAYRESULT_H_

ens/include/alibabacloud/ens/model/CreateStorageVolumeRequest.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ENS_MODEL_CREATESTORAGEVOLUMEREQUEST_H_
+#define ALIBABACLOUD_ENS_MODEL_CREATESTORAGEVOLUMEREQUEST_H_
+
+#include <alibabacloud/ens/EnsExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ens {
+namespace Model {
+class ALIBABACLOUD_ENS_EXPORT CreateStorageVolumeRequest : public RpcServiceRequest {
+public:
+	CreateStorageVolumeRequest();
+	~CreateStorageVolumeRequest();
+	std::string getEnsRegionId() const;
+	void setEnsRegionId(const std::string &ensRegionId);
+	std::string getGatewayId() const;
+	void setGatewayId(const std::string &gatewayId);
+	std::string getAuthUser() const;
+	void setAuthUser(const std::string &authUser);
+	std::string getVolumeName() const;
+	void setVolumeName(const std::string &volumeName);
+	std::string getAuthPassword() const;
+	void setAuthPassword(const std::string &authPassword);
+	std::string getAuthProtocol() const;
+	void setAuthProtocol(const std::string &authProtocol);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getIsEnable() const;
+	void setIsEnable(const std::string &isEnable);
+	std::string getIsAuth() const;
+	void setIsAuth(const std::string &isAuth);
+	std::string getStorageId() const;
+	void setStorageId(const std::string &storageId);
+
+private:
+	std::string ensRegionId_;
+	std::string gatewayId_;
+	std::string authUser_;
+	std::string volumeName_;
+	std::string authPassword_;
+	std::string authProtocol_;
+	std::string description_;
+	std::string isEnable_;
+	std::string isAuth_;
+	std::string storageId_;
+};
+} // namespace Model
+} // namespace Ens
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ENS_MODEL_CREATESTORAGEVOLUMEREQUEST_H_

ens/include/alibabacloud/ens/model/CreateStorageVolumeResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_ENS_MODEL_CREATESTORAGEVOLUMERESULT_H_
+#define ALIBABACLOUD_ENS_MODEL_CREATESTORAGEVOLUMERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ens/EnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ens
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ENS_EXPORT CreateStorageVolumeResult : public ServiceResult
+			{
+			public:
+
+
+				CreateStorageVolumeResult();
+				explicit CreateStorageVolumeResult(const std::string &payload);
+				~CreateStorageVolumeResult();
+				std::vector<std::string> getVolumeId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<std::string> volumeId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ENS_MODEL_CREATESTORAGEVOLUMERESULT_H_

ens/include/alibabacloud/ens/model/DeleteStorageGatewayRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_ENS_MODEL_DELETESTORAGEGATEWAYREQUEST_H_
+#define ALIBABACLOUD_ENS_MODEL_DELETESTORAGEGATEWAYREQUEST_H_
+
+#include <alibabacloud/ens/EnsExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ens {
+namespace Model {
+class ALIBABACLOUD_ENS_EXPORT DeleteStorageGatewayRequest : public RpcServiceRequest {
+public:
+	DeleteStorageGatewayRequest();
+	~DeleteStorageGatewayRequest();
+	std::string getGatewayId() const;
+	void setGatewayId(const std::string &gatewayId);
+
+private:
+	std::string gatewayId_;
+};
+} // namespace Model
+} // namespace Ens
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ENS_MODEL_DELETESTORAGEGATEWAYREQUEST_H_

ens/include/alibabacloud/ens/model/DeleteStorageGatewayResult.h

@@ -0,0 +1,49 @@
+/*
+ * 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.
+ */
+
+#ifndef ALIBABACLOUD_ENS_MODEL_DELETESTORAGEGATEWAYRESULT_H_
+#define ALIBABACLOUD_ENS_MODEL_DELETESTORAGEGATEWAYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ens/EnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ens
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ENS_EXPORT DeleteStorageGatewayResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteStorageGatewayResult();
+				explicit DeleteStorageGatewayResult(const std::string &payload);
+				~DeleteStorageGatewayResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ENS_MODEL_DELETESTORAGEGATEWAYRESULT_H_

ens/include/alibabacloud/ens/model/DeleteStorageVolumeRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_ENS_MODEL_DELETESTORAGEVOLUMEREQUEST_H_
+#define ALIBABACLOUD_ENS_MODEL_DELETESTORAGEVOLUMEREQUEST_H_
+
+#include <alibabacloud/ens/EnsExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ens {
+namespace Model {
+class ALIBABACLOUD_ENS_EXPORT DeleteStorageVolumeRequest : public RpcServiceRequest {
+public:
+	DeleteStorageVolumeRequest();
+	~DeleteStorageVolumeRequest();
+	std::string getVolumeId() const;
+	void setVolumeId(const std::string &volumeId);
+
+private:
+	std::string volumeId_;
+};
+} // namespace Model
+} // namespace Ens
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ENS_MODEL_DELETESTORAGEVOLUMEREQUEST_H_

ens/include/alibabacloud/ens/model/DeleteStorageVolumeResult.h

@@ -0,0 +1,49 @@
+/*
+ * 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.
+ */
+
+#ifndef ALIBABACLOUD_ENS_MODEL_DELETESTORAGEVOLUMERESULT_H_
+#define ALIBABACLOUD_ENS_MODEL_DELETESTORAGEVOLUMERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ens/EnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ens
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ENS_EXPORT DeleteStorageVolumeResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteStorageVolumeResult();
+				explicit DeleteStorageVolumeResult(const std::string &payload);
+				~DeleteStorageVolumeResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ENS_MODEL_DELETESTORAGEVOLUMERESULT_H_

ens/include/alibabacloud/ens/model/DescribeInstancesResult.h

@@ -59,7 +59,9 @@ namespace AlibabaCloud
 						std::string uuid;
 						int storage;
 						std::string category;
+						std::string encryptKeyId;
 						int size;
+						bool encrypted;
 						int diskSize;
 						std::string diskName;
 						std::string diskId;

ens/include/alibabacloud/ens/model/DescribeLoadBalancerHTTPListenerAttributeResult.h

@@ -44,6 +44,7 @@ namespace AlibabaCloud
 				std::string getHealthCheckURI()const;
 				std::string getHealthCheck()const;
 				int getIdleTimeout()const;
+				int getBackendServerPort()const;
 				int getHealthCheckConnectPort()const;
 				std::string getHealthCheckMethod()const;
 				int getBandwidth()const;
@@ -73,6 +74,7 @@ namespace AlibabaCloud
 				std::string healthCheckURI_;
 				std::string healthCheck_;
 				int idleTimeout_;
+				int backendServerPort_;
 				int healthCheckConnectPort_;
 				std::string healthCheckMethod_;
 				int bandwidth_;

ens/include/alibabacloud/ens/model/DescribeLoadBalancerHTTPSListenerAttributeResult.h

@@ -37,58 +37,60 @@ namespace AlibabaCloud
 				DescribeLoadBalancerHTTPSListenerAttributeResult();
 				explicit DescribeLoadBalancerHTTPSListenerAttributeResult(const std::string &payload);
 				~DescribeLoadBalancerHTTPSListenerAttributeResult();
-				std::string getStatus()const;
 				int getCookieTimeout()const;
-				std::string getCookie()const;
-				int getListenerPort()const;
-				int getRequestTimeout()const;
-				int getHealthCheckInterval()const;
 				std::string getDescription()const;
 				int getUnhealthyThreshold()const;
 				std::string getScheduler()const;
 				std::string getHealthCheckURI()const;
 				std::string getHealthCheck()const;
 				int getIdleTimeout()const;
-				int getHealthCheckTimeout()const;
-				std::string getListenerForward()const;
-				std::string getStickySession()const;
+				int getBackendServerPort()const;
 				int getHealthCheckConnectPort()const;
-				int getForwardPort()const;
 				std::string getHealthCheckMethod()const;
 				int getBandwidth()const;
-				int getHealthyThreshold()const;
-				std::string getHealthCheckDomain()const;
 				std::string getServerCertificateId()const;
 				std::string getStickySessionType()const;
 				std::string getHealthCheckHttpCode()const;
+				std::string getStatus()const;
+				std::string getCookie()const;
+				int getListenerPort()const;
+				int getRequestTimeout()const;
+				int getHealthCheckInterval()const;
+				int getHealthCheckTimeout()const;
+				std::string getListenerForward()const;
+				std::string getStickySession()const;
+				int getForwardPort()const;
+				int getHealthyThreshold()const;
+				std::string getHealthCheckDomain()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string status_;
 				int cookieTimeout_;
-				std::string cookie_;
-				int listenerPort_;
-				int requestTimeout_;
-				int healthCheckInterval_;
 				std::string description_;
 				int unhealthyThreshold_;
 				std::string scheduler_;
 				std::string healthCheckURI_;
 				std::string healthCheck_;
 				int idleTimeout_;
-				int healthCheckTimeout_;
-				std::string listenerForward_;
-				std::string stickySession_;
+				int backendServerPort_;
 				int healthCheckConnectPort_;
-				int forwardPort_;
 				std::string healthCheckMethod_;
 				int bandwidth_;
-				int healthyThreshold_;
-				std::string healthCheckDomain_;
 				std::string serverCertificateId_;
 				std::string stickySessionType_;
 				std::string healthCheckHttpCode_;
+				std::string status_;
+				std::string cookie_;
+				int listenerPort_;
+				int requestTimeout_;
+				int healthCheckInterval_;
+				int healthCheckTimeout_;
+				std::string listenerForward_;
+				std::string stickySession_;
+				int forwardPort_;
+				int healthyThreshold_;
+				std::string healthCheckDomain_;
 
 			};
 		}

ens/include/alibabacloud/ens/model/DescribeLoadBalancerUDPListenerAttributeResult.h

@@ -52,6 +52,7 @@ namespace AlibabaCloud
 				int getHealthyThreshold()const;
 				std::string getHealthCheckExp()const;
 				std::string getEipTransmit()const;
+				int getEstablishedTimeout()const;
 
 			protected:
 				void parse(const std::string &payload);
@@ -71,6 +72,7 @@ namespace AlibabaCloud
 				int healthyThreshold_;
 				std::string healthCheckExp_;
 				std::string eipTransmit_;
+				int establishedTimeout_;
 
 			};
 		}

ens/include/alibabacloud/ens/model/DescribeSDGDeploymentStatusRequest.h

@@ -30,17 +30,29 @@ class ALIBABACLOUD_ENS_EXPORT DescribeSDGDeploymentStatusRequest : public RpcSer
 public:
 	DescribeSDGDeploymentStatusRequest();
 	~DescribeSDGDeploymentStatusRequest();
-	std::string getPageNumber() const;
-	void setPageNumber(const std::string &pageNumber);
+	std::vector<std::string> getRegionIds() const;
+	void setRegionIds(const std::vector<std::string> &regionIds);
+	std::vector<std::string> getInstanceIds() const;
+	void setInstanceIds(const std::vector<std::string> &instanceIds);
+	std::string getStatus() const;
+	void setStatus(const std::string &status);
+	std::string getDeploymentType() const;
+	void setDeploymentType(const std::string &deploymentType);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
 	std::string getSDGId() const;
 	void setSDGId(const std::string &sDGId);
-	std::string getPageSize() const;
-	void setPageSize(const std::string &pageSize);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
 
 private:
-	std::string pageNumber_;
+	std::vector<std::string> regionIds_;
+	std::vector<std::string> instanceIds_;
+	std::string status_;
+	std::string deploymentType_;
+	int pageNumber_;
 	std::string sDGId_;
-	std::string pageSize_;
+	int pageSize_;
 };
 } // namespace Model
 } // namespace Ens

ens/include/alibabacloud/ens/model/DescribeSelfImagesResult.h

@@ -36,16 +36,17 @@ namespace AlibabaCloud
 				{
 					std::string imageOwnerAlias;
 					std::string status;
-					std::string imageName;
-					std::string snapshotId;
 					std::string architecture;
 					std::string platform;
 					std::string imageSize;
 					std::string instanceId;
 					std::string osVersion;
+					std::string computeType;
+					std::string imageStorageSize;
+					std::string imageName;
+					std::string snapshotId;
 					std::string creationTime;
 					std::string imageId;
-					std::string computeType;
 				};
 
 

ens/include/alibabacloud/ens/model/DescribeStorageGatewayRequest.h

@@ -0,0 +1,57 @@
+/*
+ * 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.
+ */
+
+#ifndef ALIBABACLOUD_ENS_MODEL_DESCRIBESTORAGEGATEWAYREQUEST_H_
+#define ALIBABACLOUD_ENS_MODEL_DESCRIBESTORAGEGATEWAYREQUEST_H_
+
+#include <alibabacloud/ens/EnsExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ens {
+namespace Model {
+class ALIBABACLOUD_ENS_EXPORT DescribeStorageGatewayRequest : public RpcServiceRequest {
+public:
+	DescribeStorageGatewayRequest();
+	~DescribeStorageGatewayRequest();
+	std::string getPageNumber() const;
+	void setPageNumber(const std::string &pageNumber);
+	std::string getEnsRegionId() const;
+	void setEnsRegionId(const std::string &ensRegionId);
+	std::string getPageSize() const;
+	void setPageSize(const std::string &pageSize);
+	std::string getGatewayId() const;
+	void setGatewayId(const std::string &gatewayId);
+	std::string getGatewayType() const;
+	void setGatewayType(const std::string &gatewayType);
+	std::string getVpcId() const;
+	void setVpcId(const std::string &vpcId);
+
+private:
+	std::string pageNumber_;
+	std::string ensRegionId_;
+	std::string pageSize_;
+	std::string gatewayId_;
+	std::string gatewayType_;
+	std::string vpcId_;
+};
+} // namespace Model
+} // namespace Ens
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBESTORAGEGATEWAYREQUEST_H_

ens/include/alibabacloud/ens/model/DescribeStorageGatewayResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_ENS_MODEL_DESCRIBESTORAGEGATEWAYRESULT_H_
+#define ALIBABACLOUD_ENS_MODEL_DESCRIBESTORAGEGATEWAYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ens/EnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ens
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ENS_EXPORT DescribeStorageGatewayResult : public ServiceResult
+			{
+			public:
+				struct StorageGatewaysItem
+				{
+					std::string storageGatewayName;
+					std::string status;
+					std::string serviceIp;
+					std::string description;
+					int storageGatewayType;
+					std::string vpcId;
+					std::string creationTime;
+					std::string cidrBlock;
+					std::string ensRegionId;
+					std::string storageGatewayId;
+				};
+
+
+				DescribeStorageGatewayResult();
+				explicit DescribeStorageGatewayResult(const std::string &payload);
+				~DescribeStorageGatewayResult();
+				std::vector<StorageGatewaysItem> getStorageGateways()const;
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<StorageGatewaysItem> storageGateways_;
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBESTORAGEGATEWAYRESULT_H_

ens/include/alibabacloud/ens/model/DescribeStorageVolumeRequest.h

@@ -0,0 +1,60 @@
+/*
+ * 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.
+ */
+
+#ifndef ALIBABACLOUD_ENS_MODEL_DESCRIBESTORAGEVOLUMEREQUEST_H_
+#define ALIBABACLOUD_ENS_MODEL_DESCRIBESTORAGEVOLUMEREQUEST_H_
+
+#include <alibabacloud/ens/EnsExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ens {
+namespace Model {
+class ALIBABACLOUD_ENS_EXPORT DescribeStorageVolumeRequest : public RpcServiceRequest {
+public:
+	DescribeStorageVolumeRequest();
+	~DescribeStorageVolumeRequest();
+	std::string getEnsRegionId() const;
+	void setEnsRegionId(const std::string &ensRegionId);
+	std::string getGatewayId() const;
+	void setGatewayId(const std::string &gatewayId);
+	std::string getVolumeId() const;
+	void setVolumeId(const std::string &volumeId);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	int getIsEnable() const;
+	void setIsEnable(int isEnable);
+	std::string getStorageId() const;
+	void setStorageId(const std::string &storageId);
+
+private:
+	std::string ensRegionId_;
+	std::string gatewayId_;
+	std::string volumeId_;
+	int pageNumber_;
+	int pageSize_;
+	int isEnable_;
+	std::string storageId_;
+};
+} // namespace Model
+} // namespace Ens
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBESTORAGEVOLUMEREQUEST_H_

ens/include/alibabacloud/ens/model/DescribeStorageVolumeResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_ENS_MODEL_DESCRIBESTORAGEVOLUMERESULT_H_
+#define ALIBABACLOUD_ENS_MODEL_DESCRIBESTORAGEVOLUMERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ens/EnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ens
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ENS_EXPORT DescribeStorageVolumeResult : public ServiceResult
+			{
+			public:
+				struct StorageVolumesItem
+				{
+					std::string storageVolumeName;
+					std::string status;
+					int isEnable;
+					std::string description;
+					int isAuth;
+					std::string creationTime;
+					std::string authProtocol;
+					std::string storageVolumeId;
+					std::string targetName;
+					std::string ensRegionId;
+					std::string storageId;
+					std::string storageGatewayId;
+				};
+
+
+				DescribeStorageVolumeResult();
+				explicit DescribeStorageVolumeResult(const std::string &payload);
+				~DescribeStorageVolumeResult();
+				std::string getTotalCount()const;
+				std::string getPageSize()const;
+				std::string getPageNumber()const;
+				std::vector<StorageVolumesItem> getStorageVolumes()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string totalCount_;
+				std::string pageSize_;
+				std::string pageNumber_;
+				std::vector<StorageVolumesItem> storageVolumes_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBESTORAGEVOLUMERESULT_H_

ens/include/alibabacloud/ens/model/PrepareUploadRequest.h

@@ -0,0 +1,60 @@
+/*
+ * 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.
+ */
+
+#ifndef ALIBABACLOUD_ENS_MODEL_PREPAREUPLOADREQUEST_H_
+#define ALIBABACLOUD_ENS_MODEL_PREPAREUPLOADREQUEST_H_
+
+#include <alibabacloud/ens/EnsExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ens {
+namespace Model {
+class ALIBABACLOUD_ENS_EXPORT PrepareUploadRequest : public RpcServiceRequest {
+public:
+	PrepareUploadRequest();
+	~PrepareUploadRequest();
+	std::string getClientIp() const;
+	void setClientIp(const std::string &clientIp);
+	std::string getEnsRegionId() const;
+	void setEnsRegionId(const std::string &ensRegionId);
+	std::string getAdditionType() const;
+	void setAdditionType(const std::string &additionType);
+	std::string getBucketName() const;
+	void setBucketName(const std::string &bucketName);
+	std::string getStation() const;
+	void setStation(const std::string &station);
+	std::string getObjectKey() const;
+	void setObjectKey(const std::string &objectKey);
+	long getStorageCost() const;
+	void setStorageCost(long storageCost);
+
+private:
+	std::string clientIp_;
+	std::string ensRegionId_;
+	std::string additionType_;
+	std::string bucketName_;
+	std::string station_;
+	std::string objectKey_;
+	long storageCost_;
+};
+} // namespace Model
+} // namespace Ens
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ENS_MODEL_PREPAREUPLOADREQUEST_H_

ens/include/alibabacloud/ens/model/PrepareUploadResult.h

@@ -0,0 +1,55 @@
+/*
+ * 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.
+ */
+
+#ifndef ALIBABACLOUD_ENS_MODEL_PREPAREUPLOADRESULT_H_
+#define ALIBABACLOUD_ENS_MODEL_PREPAREUPLOADRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ens/EnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ens
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ENS_EXPORT PrepareUploadResult : public ServiceResult
+			{
+			public:
+
+
+				PrepareUploadResult();
+				explicit PrepareUploadResult(const std::string &payload);
+				~PrepareUploadResult();
+				std::string getBucketName()const;
+				std::string getEndpoint()const;
+				std::string getAdditionInfo()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string bucketName_;
+				std::string endpoint_;
+				std::string additionInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ENS_MODEL_PREPAREUPLOADRESULT_H_

ens/include/alibabacloud/ens/model/PutBucketLifecycleResult.h

@@ -37,10 +37,12 @@ namespace AlibabaCloud
 				PutBucketLifecycleResult();
 				explicit PutBucketLifecycleResult(const std::string &payload);
 				~PutBucketLifecycleResult();
+				std::string getRuleId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string ruleId_;
 
 			};
 		}

ens/include/alibabacloud/ens/model/SetLoadBalancerUDPListenerAttributeRequest.h

@@ -32,6 +32,8 @@ public:
 	~SetLoadBalancerUDPListenerAttributeRequest();
 	std::string getProtocol() const;
 	void setProtocol(const std::string &protocol);
+	int getEstablishedTimeout() const;
+	void setEstablishedTimeout(int establishedTimeout);
 	std::string getLoadBalancerId() const;
 	void setLoadBalancerId(const std::string &loadBalancerId);
 	std::string getHealthCheckReq() const;
@@ -59,6 +61,7 @@ public:
 
 private:
 	std::string protocol_;
+	int establishedTimeout_;
 	std::string loadBalancerId_;
 	std::string healthCheckReq_;
 	int healthCheckInterval_;

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,126 +87,133 @@ 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
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getCookieTimeout()const
 {
-	return status_;
+	return cookieTimeout_;
 }
 
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getCookieTimeout()const
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getDescription()const
 {
-	return cookieTimeout_;
+	return description_;
 }
 
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getCookie()const
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getUnhealthyThreshold()const
 {
-	return cookie_;
+	return unhealthyThreshold_;
 }
 
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getListenerPort()const
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getScheduler()const
 {
-	return listenerPort_;
+	return scheduler_;
 }
 
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getRequestTimeout()const
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckURI()const
 {
-	return requestTimeout_;
+	return healthCheckURI_;
 }
 
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckInterval()const
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheck()const
 {
-	return healthCheckInterval_;
+	return healthCheck_;
 }
 
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getDescription()const
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getIdleTimeout()const
 {
-	return description_;
+	return idleTimeout_;
 }
 
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getUnhealthyThreshold()const
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getBackendServerPort()const
 {
-	return unhealthyThreshold_;
+	return backendServerPort_;
 }
 
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getScheduler()const
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckConnectPort()const
 {
-	return scheduler_;
+	return healthCheckConnectPort_;
 }
 
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckURI()const
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckMethod()const
 {
-	return healthCheckURI_;
+	return healthCheckMethod_;
 }
 
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheck()const
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getBandwidth()const
 {
-	return healthCheck_;
+	return bandwidth_;
 }
 
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getIdleTimeout()const
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getServerCertificateId()const
 {
-	return idleTimeout_;
+	return serverCertificateId_;
 }
 
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckTimeout()const
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStickySessionType()const
 {
-	return healthCheckTimeout_;
+	return stickySessionType_;
 }
 
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getListenerForward()const
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckHttpCode()const
 {
-	return listenerForward_;
+	return healthCheckHttpCode_;
 }
 
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStickySession()const
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStatus()const
 {
-	return stickySession_;
+	return status_;
 }
 
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckConnectPort()const
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getCookie()const
 {
-	return healthCheckConnectPort_;
+	return cookie_;
 }
 
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getForwardPort()const
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getListenerPort()const
 {
-	return forwardPort_;
+	return listenerPort_;
 }
 
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckMethod()const
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getRequestTimeout()const
 {
-	return healthCheckMethod_;
+	return requestTimeout_;
 }
 
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getBandwidth()const
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckInterval()const
 {
-	return bandwidth_;
+	return healthCheckInterval_;
 }
 
-int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthyThreshold()const
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckTimeout()const
 {
-	return healthyThreshold_;
+	return healthCheckTimeout_;
 }
 
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckDomain()const
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getListenerForward()const
 {
-	return healthCheckDomain_;
+	return listenerForward_;
 }
 
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getServerCertificateId()const
+std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStickySession()const
 {
-	return serverCertificateId_;
+	return stickySession_;
 }
 
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStickySessionType()const
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getForwardPort()const
 {
-	return stickySessionType_;
+	return forwardPort_;
 }
 
-std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckHttpCode()const
+int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthyThreshold()const
 {
-	return healthCheckHttpCode_;
+	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_;
 }