Add TriggerRemoteSync api.

CHANGELOG

@@ -1,3 +1,6 @@
+2021-05-28 Version: 1.36.760
+- Add TriggerRemoteSync api.
+
 2021-05-28 Version: 1.36.759
 - Create Lindorm Open api.
 

VERSION

@@ -1 +1 @@
-1.36.759
+1.36.760

sgw/CMakeLists.txt

@@ -45,6 +45,8 @@ set(sgw_public_header_model
 	include/alibabacloud/sgw/model/CheckUpgradeVersionResult.h
 	include/alibabacloud/sgw/model/CreateCacheRequest.h
 	include/alibabacloud/sgw/model/CreateCacheResult.h
+	include/alibabacloud/sgw/model/CreateElasticGatewayPrivateZoneRequest.h
+	include/alibabacloud/sgw/model/CreateElasticGatewayPrivateZoneResult.h
 	include/alibabacloud/sgw/model/CreateExpressSyncRequest.h
 	include/alibabacloud/sgw/model/CreateExpressSyncResult.h
 	include/alibabacloud/sgw/model/CreateGatewayRequest.h
@@ -61,6 +63,8 @@ set(sgw_public_header_model
 	include/alibabacloud/sgw/model/CreateGatewaySMBUserResult.h
 	include/alibabacloud/sgw/model/CreateStorageBundleRequest.h
 	include/alibabacloud/sgw/model/CreateStorageBundleResult.h
+	include/alibabacloud/sgw/model/DeleteElasticGatewayPrivateZoneRequest.h
+	include/alibabacloud/sgw/model/DeleteElasticGatewayPrivateZoneResult.h
 	include/alibabacloud/sgw/model/DeleteExpressSyncRequest.h
 	include/alibabacloud/sgw/model/DeleteExpressSyncResult.h
 	include/alibabacloud/sgw/model/DeleteGatewayRequest.h
@@ -135,6 +139,8 @@ set(sgw_public_header_model
 	include/alibabacloud/sgw/model/DescribeGatewayLogsResult.h
 	include/alibabacloud/sgw/model/DescribeGatewayModificationClassesRequest.h
 	include/alibabacloud/sgw/model/DescribeGatewayModificationClassesResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayNFSClientsRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayNFSClientsResult.h
 	include/alibabacloud/sgw/model/DescribeGatewaySMBUsersRequest.h
 	include/alibabacloud/sgw/model/DescribeGatewaySMBUsersResult.h
 	include/alibabacloud/sgw/model/DescribeGatewayStatisticsRequest.h
@@ -181,6 +187,10 @@ set(sgw_public_header_model
 	include/alibabacloud/sgw/model/DescribeZonesResult.h
 	include/alibabacloud/sgw/model/DisableGatewayLoggingRequest.h
 	include/alibabacloud/sgw/model/DisableGatewayLoggingResult.h
+	include/alibabacloud/sgw/model/DisableGatewayNFSVersionRequest.h
+	include/alibabacloud/sgw/model/DisableGatewayNFSVersionResult.h
+	include/alibabacloud/sgw/model/EnableGatewayIpv6Request.h
+	include/alibabacloud/sgw/model/EnableGatewayIpv6Result.h
 	include/alibabacloud/sgw/model/EnableGatewayLoggingRequest.h
 	include/alibabacloud/sgw/model/EnableGatewayLoggingResult.h
 	include/alibabacloud/sgw/model/ExpandCacheDiskRequest.h
@@ -203,8 +213,12 @@ set(sgw_public_header_model
 	include/alibabacloud/sgw/model/ModifyGatewayClassResult.h
 	include/alibabacloud/sgw/model/ModifyGatewayFileShareRequest.h
 	include/alibabacloud/sgw/model/ModifyGatewayFileShareResult.h
+	include/alibabacloud/sgw/model/ModifyGatewayFileShareWatermarkRequest.h
+	include/alibabacloud/sgw/model/ModifyGatewayFileShareWatermarkResult.h
 	include/alibabacloud/sgw/model/ModifyStorageBundleRequest.h
 	include/alibabacloud/sgw/model/ModifyStorageBundleResult.h
+	include/alibabacloud/sgw/model/OpenSgwServiceRequest.h
+	include/alibabacloud/sgw/model/OpenSgwServiceResult.h
 	include/alibabacloud/sgw/model/OperateGatewayRequest.h
 	include/alibabacloud/sgw/model/OperateGatewayResult.h
 	include/alibabacloud/sgw/model/ReleaseServiceRequest.h
@@ -237,6 +251,8 @@ set(sgw_public_header_model
 	include/alibabacloud/sgw/model/SwitchToSubscriptionResult.h
 	include/alibabacloud/sgw/model/TagResourcesRequest.h
 	include/alibabacloud/sgw/model/TagResourcesResult.h
+	include/alibabacloud/sgw/model/TriggerGatewayRemoteSyncRequest.h
+	include/alibabacloud/sgw/model/TriggerGatewayRemoteSyncResult.h
 	include/alibabacloud/sgw/model/UntagResourcesRequest.h
 	include/alibabacloud/sgw/model/UntagResourcesResult.h
 	include/alibabacloud/sgw/model/UpdateGatewayBlockVolumeRequest.h
@@ -278,6 +294,8 @@ set(sgw_src
 	src/model/CheckUpgradeVersionResult.cc
 	src/model/CreateCacheRequest.cc
 	src/model/CreateCacheResult.cc
+	src/model/CreateElasticGatewayPrivateZoneRequest.cc
+	src/model/CreateElasticGatewayPrivateZoneResult.cc
 	src/model/CreateExpressSyncRequest.cc
 	src/model/CreateExpressSyncResult.cc
 	src/model/CreateGatewayRequest.cc
@@ -294,6 +312,8 @@ set(sgw_src
 	src/model/CreateGatewaySMBUserResult.cc
 	src/model/CreateStorageBundleRequest.cc
 	src/model/CreateStorageBundleResult.cc
+	src/model/DeleteElasticGatewayPrivateZoneRequest.cc
+	src/model/DeleteElasticGatewayPrivateZoneResult.cc
 	src/model/DeleteExpressSyncRequest.cc
 	src/model/DeleteExpressSyncResult.cc
 	src/model/DeleteGatewayRequest.cc
@@ -368,6 +388,8 @@ set(sgw_src
 	src/model/DescribeGatewayLogsResult.cc
 	src/model/DescribeGatewayModificationClassesRequest.cc
 	src/model/DescribeGatewayModificationClassesResult.cc
+	src/model/DescribeGatewayNFSClientsRequest.cc
+	src/model/DescribeGatewayNFSClientsResult.cc
 	src/model/DescribeGatewaySMBUsersRequest.cc
 	src/model/DescribeGatewaySMBUsersResult.cc
 	src/model/DescribeGatewayStatisticsRequest.cc
@@ -414,6 +436,10 @@ set(sgw_src
 	src/model/DescribeZonesResult.cc
 	src/model/DisableGatewayLoggingRequest.cc
 	src/model/DisableGatewayLoggingResult.cc
+	src/model/DisableGatewayNFSVersionRequest.cc
+	src/model/DisableGatewayNFSVersionResult.cc
+	src/model/EnableGatewayIpv6Request.cc
+	src/model/EnableGatewayIpv6Result.cc
 	src/model/EnableGatewayLoggingRequest.cc
 	src/model/EnableGatewayLoggingResult.cc
 	src/model/ExpandCacheDiskRequest.cc
@@ -436,8 +462,12 @@ set(sgw_src
 	src/model/ModifyGatewayClassResult.cc
 	src/model/ModifyGatewayFileShareRequest.cc
 	src/model/ModifyGatewayFileShareResult.cc
+	src/model/ModifyGatewayFileShareWatermarkRequest.cc
+	src/model/ModifyGatewayFileShareWatermarkResult.cc
 	src/model/ModifyStorageBundleRequest.cc
 	src/model/ModifyStorageBundleResult.cc
+	src/model/OpenSgwServiceRequest.cc
+	src/model/OpenSgwServiceResult.cc
 	src/model/OperateGatewayRequest.cc
 	src/model/OperateGatewayResult.cc
 	src/model/ReleaseServiceRequest.cc
@@ -470,6 +500,8 @@ set(sgw_src
 	src/model/SwitchToSubscriptionResult.cc
 	src/model/TagResourcesRequest.cc
 	src/model/TagResourcesResult.cc
+	src/model/TriggerGatewayRemoteSyncRequest.cc
+	src/model/TriggerGatewayRemoteSyncResult.cc
 	src/model/UntagResourcesRequest.cc
 	src/model/UntagResourcesResult.cc
 	src/model/UpdateGatewayBlockVolumeRequest.cc

sgw/include/alibabacloud/sgw/SgwClient.h

@@ -46,6 +46,8 @@
 #include "model/CheckUpgradeVersionResult.h"
 #include "model/CreateCacheRequest.h"
 #include "model/CreateCacheResult.h"
+#include "model/CreateElasticGatewayPrivateZoneRequest.h"
+#include "model/CreateElasticGatewayPrivateZoneResult.h"
 #include "model/CreateExpressSyncRequest.h"
 #include "model/CreateExpressSyncResult.h"
 #include "model/CreateGatewayRequest.h"
@@ -62,6 +64,8 @@
 #include "model/CreateGatewaySMBUserResult.h"
 #include "model/CreateStorageBundleRequest.h"
 #include "model/CreateStorageBundleResult.h"
+#include "model/DeleteElasticGatewayPrivateZoneRequest.h"
+#include "model/DeleteElasticGatewayPrivateZoneResult.h"
 #include "model/DeleteExpressSyncRequest.h"
 #include "model/DeleteExpressSyncResult.h"
 #include "model/DeleteGatewayRequest.h"
@@ -136,6 +140,8 @@
 #include "model/DescribeGatewayLogsResult.h"
 #include "model/DescribeGatewayModificationClassesRequest.h"
 #include "model/DescribeGatewayModificationClassesResult.h"
+#include "model/DescribeGatewayNFSClientsRequest.h"
+#include "model/DescribeGatewayNFSClientsResult.h"
 #include "model/DescribeGatewaySMBUsersRequest.h"
 #include "model/DescribeGatewaySMBUsersResult.h"
 #include "model/DescribeGatewayStatisticsRequest.h"
@@ -182,6 +188,10 @@
 #include "model/DescribeZonesResult.h"
 #include "model/DisableGatewayLoggingRequest.h"
 #include "model/DisableGatewayLoggingResult.h"
+#include "model/DisableGatewayNFSVersionRequest.h"
+#include "model/DisableGatewayNFSVersionResult.h"
+#include "model/EnableGatewayIpv6Request.h"
+#include "model/EnableGatewayIpv6Result.h"
 #include "model/EnableGatewayLoggingRequest.h"
 #include "model/EnableGatewayLoggingResult.h"
 #include "model/ExpandCacheDiskRequest.h"
@@ -204,8 +214,12 @@
 #include "model/ModifyGatewayClassResult.h"
 #include "model/ModifyGatewayFileShareRequest.h"
 #include "model/ModifyGatewayFileShareResult.h"
+#include "model/ModifyGatewayFileShareWatermarkRequest.h"
+#include "model/ModifyGatewayFileShareWatermarkResult.h"
 #include "model/ModifyStorageBundleRequest.h"
 #include "model/ModifyStorageBundleResult.h"
+#include "model/OpenSgwServiceRequest.h"
+#include "model/OpenSgwServiceResult.h"
 #include "model/OperateGatewayRequest.h"
 #include "model/OperateGatewayResult.h"
 #include "model/ReleaseServiceRequest.h"
@@ -238,6 +252,8 @@
 #include "model/SwitchToSubscriptionResult.h"
 #include "model/TagResourcesRequest.h"
 #include "model/TagResourcesResult.h"
+#include "model/TriggerGatewayRemoteSyncRequest.h"
+#include "model/TriggerGatewayRemoteSyncResult.h"
 #include "model/UntagResourcesRequest.h"
 #include "model/UntagResourcesResult.h"
 #include "model/UpdateGatewayBlockVolumeRequest.h"
@@ -297,6 +313,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateCacheResult> CreateCacheOutcome;
 			typedef std::future<CreateCacheOutcome> CreateCacheOutcomeCallable;
 			typedef std::function<void(const SgwClient*, const Model::CreateCacheRequest&, const CreateCacheOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCacheAsyncHandler;
+			typedef Outcome<Error, Model::CreateElasticGatewayPrivateZoneResult> CreateElasticGatewayPrivateZoneOutcome;
+			typedef std::future<CreateElasticGatewayPrivateZoneOutcome> CreateElasticGatewayPrivateZoneOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::CreateElasticGatewayPrivateZoneRequest&, const CreateElasticGatewayPrivateZoneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateElasticGatewayPrivateZoneAsyncHandler;
 			typedef Outcome<Error, Model::CreateExpressSyncResult> CreateExpressSyncOutcome;
 			typedef std::future<CreateExpressSyncOutcome> CreateExpressSyncOutcomeCallable;
 			typedef std::function<void(const SgwClient*, const Model::CreateExpressSyncRequest&, const CreateExpressSyncOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateExpressSyncAsyncHandler;
@@ -321,6 +340,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateStorageBundleResult> CreateStorageBundleOutcome;
 			typedef std::future<CreateStorageBundleOutcome> CreateStorageBundleOutcomeCallable;
 			typedef std::function<void(const SgwClient*, const Model::CreateStorageBundleRequest&, const CreateStorageBundleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateStorageBundleAsyncHandler;
+			typedef Outcome<Error, Model::DeleteElasticGatewayPrivateZoneResult> DeleteElasticGatewayPrivateZoneOutcome;
+			typedef std::future<DeleteElasticGatewayPrivateZoneOutcome> DeleteElasticGatewayPrivateZoneOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DeleteElasticGatewayPrivateZoneRequest&, const DeleteElasticGatewayPrivateZoneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteElasticGatewayPrivateZoneAsyncHandler;
 			typedef Outcome<Error, Model::DeleteExpressSyncResult> DeleteExpressSyncOutcome;
 			typedef std::future<DeleteExpressSyncOutcome> DeleteExpressSyncOutcomeCallable;
 			typedef std::function<void(const SgwClient*, const Model::DeleteExpressSyncRequest&, const DeleteExpressSyncOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteExpressSyncAsyncHandler;
@@ -432,6 +454,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeGatewayModificationClassesResult> DescribeGatewayModificationClassesOutcome;
 			typedef std::future<DescribeGatewayModificationClassesOutcome> DescribeGatewayModificationClassesOutcomeCallable;
 			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayModificationClassesRequest&, const DescribeGatewayModificationClassesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayModificationClassesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayNFSClientsResult> DescribeGatewayNFSClientsOutcome;
+			typedef std::future<DescribeGatewayNFSClientsOutcome> DescribeGatewayNFSClientsOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayNFSClientsRequest&, const DescribeGatewayNFSClientsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayNFSClientsAsyncHandler;
 			typedef Outcome<Error, Model::DescribeGatewaySMBUsersResult> DescribeGatewaySMBUsersOutcome;
 			typedef std::future<DescribeGatewaySMBUsersOutcome> DescribeGatewaySMBUsersOutcomeCallable;
 			typedef std::function<void(const SgwClient*, const Model::DescribeGatewaySMBUsersRequest&, const DescribeGatewaySMBUsersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewaySMBUsersAsyncHandler;
@@ -501,6 +526,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DisableGatewayLoggingResult> DisableGatewayLoggingOutcome;
 			typedef std::future<DisableGatewayLoggingOutcome> DisableGatewayLoggingOutcomeCallable;
 			typedef std::function<void(const SgwClient*, const Model::DisableGatewayLoggingRequest&, const DisableGatewayLoggingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableGatewayLoggingAsyncHandler;
+			typedef Outcome<Error, Model::DisableGatewayNFSVersionResult> DisableGatewayNFSVersionOutcome;
+			typedef std::future<DisableGatewayNFSVersionOutcome> DisableGatewayNFSVersionOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DisableGatewayNFSVersionRequest&, const DisableGatewayNFSVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableGatewayNFSVersionAsyncHandler;
+			typedef Outcome<Error, Model::EnableGatewayIpv6Result> EnableGatewayIpv6Outcome;
+			typedef std::future<EnableGatewayIpv6Outcome> EnableGatewayIpv6OutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::EnableGatewayIpv6Request&, const EnableGatewayIpv6Outcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableGatewayIpv6AsyncHandler;
 			typedef Outcome<Error, Model::EnableGatewayLoggingResult> EnableGatewayLoggingOutcome;
 			typedef std::future<EnableGatewayLoggingOutcome> EnableGatewayLoggingOutcomeCallable;
 			typedef std::function<void(const SgwClient*, const Model::EnableGatewayLoggingRequest&, const EnableGatewayLoggingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableGatewayLoggingAsyncHandler;
@@ -534,9 +565,15 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ModifyGatewayFileShareResult> ModifyGatewayFileShareOutcome;
 			typedef std::future<ModifyGatewayFileShareOutcome> ModifyGatewayFileShareOutcomeCallable;
 			typedef std::function<void(const SgwClient*, const Model::ModifyGatewayFileShareRequest&, const ModifyGatewayFileShareOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyGatewayFileShareAsyncHandler;
+			typedef Outcome<Error, Model::ModifyGatewayFileShareWatermarkResult> ModifyGatewayFileShareWatermarkOutcome;
+			typedef std::future<ModifyGatewayFileShareWatermarkOutcome> ModifyGatewayFileShareWatermarkOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::ModifyGatewayFileShareWatermarkRequest&, const ModifyGatewayFileShareWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyGatewayFileShareWatermarkAsyncHandler;
 			typedef Outcome<Error, Model::ModifyStorageBundleResult> ModifyStorageBundleOutcome;
 			typedef std::future<ModifyStorageBundleOutcome> ModifyStorageBundleOutcomeCallable;
 			typedef std::function<void(const SgwClient*, const Model::ModifyStorageBundleRequest&, const ModifyStorageBundleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyStorageBundleAsyncHandler;
+			typedef Outcome<Error, Model::OpenSgwServiceResult> OpenSgwServiceOutcome;
+			typedef std::future<OpenSgwServiceOutcome> OpenSgwServiceOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::OpenSgwServiceRequest&, const OpenSgwServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> OpenSgwServiceAsyncHandler;
 			typedef Outcome<Error, Model::OperateGatewayResult> OperateGatewayOutcome;
 			typedef std::future<OperateGatewayOutcome> OperateGatewayOutcomeCallable;
 			typedef std::function<void(const SgwClient*, const Model::OperateGatewayRequest&, const OperateGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> OperateGatewayAsyncHandler;
@@ -585,6 +622,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::TagResourcesResult> TagResourcesOutcome;
 			typedef std::future<TagResourcesOutcome> TagResourcesOutcomeCallable;
 			typedef std::function<void(const SgwClient*, const Model::TagResourcesRequest&, const TagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TagResourcesAsyncHandler;
+			typedef Outcome<Error, Model::TriggerGatewayRemoteSyncResult> TriggerGatewayRemoteSyncOutcome;
+			typedef std::future<TriggerGatewayRemoteSyncOutcome> TriggerGatewayRemoteSyncOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::TriggerGatewayRemoteSyncRequest&, const TriggerGatewayRemoteSyncOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TriggerGatewayRemoteSyncAsyncHandler;
 			typedef Outcome<Error, Model::UntagResourcesResult> UntagResourcesOutcome;
 			typedef std::future<UntagResourcesOutcome> UntagResourcesOutcomeCallable;
 			typedef std::function<void(const SgwClient*, const Model::UntagResourcesRequest&, const UntagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UntagResourcesAsyncHandler;
@@ -647,6 +687,9 @@ namespace AlibabaCloud
 			CreateCacheOutcome createCache(const Model::CreateCacheRequest &request)const;
 			void createCacheAsync(const Model::CreateCacheRequest& request, const CreateCacheAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateCacheOutcomeCallable createCacheCallable(const Model::CreateCacheRequest& request) const;
+			CreateElasticGatewayPrivateZoneOutcome createElasticGatewayPrivateZone(const Model::CreateElasticGatewayPrivateZoneRequest &request)const;
+			void createElasticGatewayPrivateZoneAsync(const Model::CreateElasticGatewayPrivateZoneRequest& request, const CreateElasticGatewayPrivateZoneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateElasticGatewayPrivateZoneOutcomeCallable createElasticGatewayPrivateZoneCallable(const Model::CreateElasticGatewayPrivateZoneRequest& request) const;
 			CreateExpressSyncOutcome createExpressSync(const Model::CreateExpressSyncRequest &request)const;
 			void createExpressSyncAsync(const Model::CreateExpressSyncRequest& request, const CreateExpressSyncAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateExpressSyncOutcomeCallable createExpressSyncCallable(const Model::CreateExpressSyncRequest& request) const;
@@ -671,6 +714,9 @@ namespace AlibabaCloud
 			CreateStorageBundleOutcome createStorageBundle(const Model::CreateStorageBundleRequest &request)const;
 			void createStorageBundleAsync(const Model::CreateStorageBundleRequest& request, const CreateStorageBundleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateStorageBundleOutcomeCallable createStorageBundleCallable(const Model::CreateStorageBundleRequest& request) const;
+			DeleteElasticGatewayPrivateZoneOutcome deleteElasticGatewayPrivateZone(const Model::DeleteElasticGatewayPrivateZoneRequest &request)const;
+			void deleteElasticGatewayPrivateZoneAsync(const Model::DeleteElasticGatewayPrivateZoneRequest& request, const DeleteElasticGatewayPrivateZoneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteElasticGatewayPrivateZoneOutcomeCallable deleteElasticGatewayPrivateZoneCallable(const Model::DeleteElasticGatewayPrivateZoneRequest& request) const;
 			DeleteExpressSyncOutcome deleteExpressSync(const Model::DeleteExpressSyncRequest &request)const;
 			void deleteExpressSyncAsync(const Model::DeleteExpressSyncRequest& request, const DeleteExpressSyncAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteExpressSyncOutcomeCallable deleteExpressSyncCallable(const Model::DeleteExpressSyncRequest& request) const;
@@ -782,6 +828,9 @@ namespace AlibabaCloud
 			DescribeGatewayModificationClassesOutcome describeGatewayModificationClasses(const Model::DescribeGatewayModificationClassesRequest &request)const;
 			void describeGatewayModificationClassesAsync(const Model::DescribeGatewayModificationClassesRequest& request, const DescribeGatewayModificationClassesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeGatewayModificationClassesOutcomeCallable describeGatewayModificationClassesCallable(const Model::DescribeGatewayModificationClassesRequest& request) const;
+			DescribeGatewayNFSClientsOutcome describeGatewayNFSClients(const Model::DescribeGatewayNFSClientsRequest &request)const;
+			void describeGatewayNFSClientsAsync(const Model::DescribeGatewayNFSClientsRequest& request, const DescribeGatewayNFSClientsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayNFSClientsOutcomeCallable describeGatewayNFSClientsCallable(const Model::DescribeGatewayNFSClientsRequest& request) const;
 			DescribeGatewaySMBUsersOutcome describeGatewaySMBUsers(const Model::DescribeGatewaySMBUsersRequest &request)const;
 			void describeGatewaySMBUsersAsync(const Model::DescribeGatewaySMBUsersRequest& request, const DescribeGatewaySMBUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeGatewaySMBUsersOutcomeCallable describeGatewaySMBUsersCallable(const Model::DescribeGatewaySMBUsersRequest& request) const;
@@ -851,6 +900,12 @@ namespace AlibabaCloud
 			DisableGatewayLoggingOutcome disableGatewayLogging(const Model::DisableGatewayLoggingRequest &request)const;
 			void disableGatewayLoggingAsync(const Model::DisableGatewayLoggingRequest& request, const DisableGatewayLoggingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DisableGatewayLoggingOutcomeCallable disableGatewayLoggingCallable(const Model::DisableGatewayLoggingRequest& request) const;
+			DisableGatewayNFSVersionOutcome disableGatewayNFSVersion(const Model::DisableGatewayNFSVersionRequest &request)const;
+			void disableGatewayNFSVersionAsync(const Model::DisableGatewayNFSVersionRequest& request, const DisableGatewayNFSVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DisableGatewayNFSVersionOutcomeCallable disableGatewayNFSVersionCallable(const Model::DisableGatewayNFSVersionRequest& request) const;
+			EnableGatewayIpv6Outcome enableGatewayIpv6(const Model::EnableGatewayIpv6Request &request)const;
+			void enableGatewayIpv6Async(const Model::EnableGatewayIpv6Request& request, const EnableGatewayIpv6AsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EnableGatewayIpv6OutcomeCallable enableGatewayIpv6Callable(const Model::EnableGatewayIpv6Request& request) const;
 			EnableGatewayLoggingOutcome enableGatewayLogging(const Model::EnableGatewayLoggingRequest &request)const;
 			void enableGatewayLoggingAsync(const Model::EnableGatewayLoggingRequest& request, const EnableGatewayLoggingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			EnableGatewayLoggingOutcomeCallable enableGatewayLoggingCallable(const Model::EnableGatewayLoggingRequest& request) const;
@@ -884,9 +939,15 @@ namespace AlibabaCloud
 			ModifyGatewayFileShareOutcome modifyGatewayFileShare(const Model::ModifyGatewayFileShareRequest &request)const;
 			void modifyGatewayFileShareAsync(const Model::ModifyGatewayFileShareRequest& request, const ModifyGatewayFileShareAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyGatewayFileShareOutcomeCallable modifyGatewayFileShareCallable(const Model::ModifyGatewayFileShareRequest& request) const;
+			ModifyGatewayFileShareWatermarkOutcome modifyGatewayFileShareWatermark(const Model::ModifyGatewayFileShareWatermarkRequest &request)const;
+			void modifyGatewayFileShareWatermarkAsync(const Model::ModifyGatewayFileShareWatermarkRequest& request, const ModifyGatewayFileShareWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyGatewayFileShareWatermarkOutcomeCallable modifyGatewayFileShareWatermarkCallable(const Model::ModifyGatewayFileShareWatermarkRequest& request) const;
 			ModifyStorageBundleOutcome modifyStorageBundle(const Model::ModifyStorageBundleRequest &request)const;
 			void modifyStorageBundleAsync(const Model::ModifyStorageBundleRequest& request, const ModifyStorageBundleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyStorageBundleOutcomeCallable modifyStorageBundleCallable(const Model::ModifyStorageBundleRequest& request) const;
+			OpenSgwServiceOutcome openSgwService(const Model::OpenSgwServiceRequest &request)const;
+			void openSgwServiceAsync(const Model::OpenSgwServiceRequest& request, const OpenSgwServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			OpenSgwServiceOutcomeCallable openSgwServiceCallable(const Model::OpenSgwServiceRequest& request) const;
 			OperateGatewayOutcome operateGateway(const Model::OperateGatewayRequest &request)const;
 			void operateGatewayAsync(const Model::OperateGatewayRequest& request, const OperateGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			OperateGatewayOutcomeCallable operateGatewayCallable(const Model::OperateGatewayRequest& request) const;
@@ -935,6 +996,9 @@ namespace AlibabaCloud
 			TagResourcesOutcome tagResources(const Model::TagResourcesRequest &request)const;
 			void tagResourcesAsync(const Model::TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			TagResourcesOutcomeCallable tagResourcesCallable(const Model::TagResourcesRequest& request) const;
+			TriggerGatewayRemoteSyncOutcome triggerGatewayRemoteSync(const Model::TriggerGatewayRemoteSyncRequest &request)const;
+			void triggerGatewayRemoteSyncAsync(const Model::TriggerGatewayRemoteSyncRequest& request, const TriggerGatewayRemoteSyncAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			TriggerGatewayRemoteSyncOutcomeCallable triggerGatewayRemoteSyncCallable(const Model::TriggerGatewayRemoteSyncRequest& request) const;
 			UntagResourcesOutcome untagResources(const Model::UntagResourcesRequest &request)const;
 			void untagResourcesAsync(const Model::UntagResourcesRequest& request, const UntagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UntagResourcesOutcomeCallable untagResourcesCallable(const Model::UntagResourcesRequest& request) const;

sgw/include/alibabacloud/sgw/model/CreateElasticGatewayPrivateZoneRequest.h

@@ -0,0 +1,54 @@
+/*
+ * 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_SGW_MODEL_CREATEELASTICGATEWAYPRIVATEZONEREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_CREATEELASTICGATEWAYPRIVATEZONEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/sgw/SgwExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sgw
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SGW_EXPORT CreateElasticGatewayPrivateZoneRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateElasticGatewayPrivateZoneRequest();
+				~CreateElasticGatewayPrivateZoneRequest();
+
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getGatewayId()const;
+				void setGatewayId(const std::string& gatewayId);
+
+            private:
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string gatewayId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CREATEELASTICGATEWAYPRIVATEZONEREQUEST_H_

sgw/include/alibabacloud/sgw/model/CreateElasticGatewayPrivateZoneResult.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_SGW_MODEL_CREATEELASTICGATEWAYPRIVATEZONERESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_CREATEELASTICGATEWAYPRIVATEZONERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/sgw/SgwExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sgw
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SGW_EXPORT CreateElasticGatewayPrivateZoneResult : public ServiceResult
+			{
+			public:
+
+
+				CreateElasticGatewayPrivateZoneResult();
+				explicit CreateElasticGatewayPrivateZoneResult(const std::string &payload);
+				~CreateElasticGatewayPrivateZoneResult();
+				std::string getTaskId()const;
+				std::string getMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string taskId_;
+				std::string message_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CREATEELASTICGATEWAYPRIVATEZONERESULT_H_

sgw/include/alibabacloud/sgw/model/CreateGatewayFileShareRequest.h

@@ -41,6 +41,8 @@ namespace AlibabaCloud
 				void setOssEndpoint(const std::string& ossEndpoint);
 				std::string getReadWriteClientList()const;
 				void setReadWriteClientList(const std::string& readWriteClientList);
+				bool getBypassCacheRead()const;
+				void setBypassCacheRead(bool bypassCacheRead);
 				int getBackendLimit()const;
 				void setBackendLimit(int backendLimit);
 				std::string getSquash()const;
@@ -97,6 +99,8 @@ namespace AlibabaCloud
 				void setEnabled(bool enabled);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getServerSideAlgorithm()const;
+				void setServerSideAlgorithm(const std::string& serverSideAlgorithm);
 				std::string getServerSideCmk()const;
 				void setServerSideCmk(const std::string& serverSideCmk);
 				bool getServerSideEncryption()const;
@@ -120,6 +124,7 @@ namespace AlibabaCloud
 				bool inPlace_;
 				std::string ossEndpoint_;
 				std::string readWriteClientList_;
+				bool bypassCacheRead_;
 				int backendLimit_;
 				std::string squash_;
 				std::string readOnlyClientList_;
@@ -148,6 +153,7 @@ namespace AlibabaCloud
 				int pollingInterval_;
 				bool enabled_;
 				std::string accessKeyId_;
+				std::string serverSideAlgorithm_;
 				std::string serverSideCmk_;
 				bool serverSideEncryption_;
 				bool ignoreDelete_;

sgw/include/alibabacloud/sgw/model/DeleteElasticGatewayPrivateZoneRequest.h

@@ -0,0 +1,54 @@
+/*
+ * 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_SGW_MODEL_DELETEELASTICGATEWAYPRIVATEZONEREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_DELETEELASTICGATEWAYPRIVATEZONEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/sgw/SgwExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sgw
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SGW_EXPORT DeleteElasticGatewayPrivateZoneRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteElasticGatewayPrivateZoneRequest();
+				~DeleteElasticGatewayPrivateZoneRequest();
+
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getGatewayId()const;
+				void setGatewayId(const std::string& gatewayId);
+
+            private:
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string gatewayId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_DELETEELASTICGATEWAYPRIVATEZONEREQUEST_H_

sgw/include/alibabacloud/sgw/model/DeleteElasticGatewayPrivateZoneResult.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_SGW_MODEL_DELETEELASTICGATEWAYPRIVATEZONERESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_DELETEELASTICGATEWAYPRIVATEZONERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/sgw/SgwExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sgw
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SGW_EXPORT DeleteElasticGatewayPrivateZoneResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteElasticGatewayPrivateZoneResult();
+				explicit DeleteElasticGatewayPrivateZoneResult(const std::string &payload);
+				~DeleteElasticGatewayPrivateZoneResult();
+				std::string getTaskId()const;
+				std::string getMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string taskId_;
+				std::string message_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_DELETEELASTICGATEWAYPRIVATEZONERESULT_H_

sgw/include/alibabacloud/sgw/model/DeleteGatewayRequest.h

@@ -37,15 +37,21 @@ namespace AlibabaCloud
 
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getReasonDetail()const;
+				void setReasonDetail(const std::string& reasonDetail);
 				std::string getSecurityToken()const;
 				void setSecurityToken(const std::string& securityToken);
 				std::string getGatewayId()const;
 				void setGatewayId(const std::string& gatewayId);
+				std::string getReasonType()const;
+				void setReasonType(const std::string& reasonType);
 
             private:
 				std::string accessKeyId_;
+				std::string reasonDetail_;
 				std::string securityToken_;
 				std::string gatewayId_;
+				std::string reasonType_;
 
 			};
 		}

sgw/include/alibabacloud/sgw/model/DescribeGatewayCachesResult.h

@@ -43,6 +43,7 @@ namespace AlibabaCloud
 					int expireStatus;
 					bool isUsed;
 					long iops;
+					std::string subscriptionInstanceId;
 					std::string localFilePath;
 					std::string cacheType;
 				};

sgw/include/alibabacloud/sgw/model/DescribeGatewayCapacityLimitResult.h

@@ -39,9 +39,9 @@ namespace AlibabaCloud
 				~DescribeGatewayCapacityLimitResult();
 				long getFileSystemSizeInTB()const;
 				std::string getMessage()const;
-				std::string getCode()const;
-				long getFileNumber()const;
 				bool getIsMetadataSeparate()const;
+				long getFileNumber()const;
+				std::string getCode()const;
 				bool getSuccess()const;
 
 			protected:
@@ -49,9 +49,9 @@ namespace AlibabaCloud
 			private:
 				long fileSystemSizeInTB_;
 				std::string message_;
-				std::string code_;
-				long fileNumber_;
 				bool isMetadataSeparate_;
+				long fileNumber_;
+				std::string code_;
 				bool success_;
 
 			};

sgw/include/alibabacloud/sgw/model/DescribeGatewayFileSharesResult.h

@@ -36,16 +36,18 @@ namespace AlibabaCloud
 				{
 					long fileNumLimit;
 					std::string bucketInfos;
+					bool throttling;
 					long totalDownload;
 					long inRate;
 					std::string address;
 					long totalUpload;
 					long size;
 					int downloadLimit;
+					int highWatermark;
 					long downloadQueue;
-					std::string localPath;
-					long ossUsed;
 					std::string clientSideCmk;
+					long ossUsed;
+					std::string localPath;
 					std::string serverSideCmk;
 					int beLimit;
 					std::string name;
@@ -57,6 +59,7 @@ namespace AlibabaCloud
 					bool supportArchive;
 					std::string roUserList;
 					bool browsable;
+					bool bypassCacheRead;
 					std::string obsoleteBuckets;
 					bool bucketsStub;
 					bool fastReclaim;
@@ -68,25 +71,27 @@ namespace AlibabaCloud
 					bool inPlace;
 					std::string ossBucketName;
 					int pollingInterval;
+					std::string serverSideAlgorithm;
 					std::string diskId;
-					bool remoteSync;
 					bool accessBasedEnumeration;
-					std::string rwUserList;
+					bool remoteSync;
 					bool windowsAcl;
+					std::string rwUserList;
 					long fsSizeLimit;
 					std::string cacheMode;
 					bool transferAcceleration;
 					long downloadRate;
 					std::string squash;
-					std::string roClientList;
 					std::string nfsFullPath;
+					std::string roClientList;
+					int lowWatermark;
 					std::string ossEndpoint;
 					bool nfsV4Optimization;
 					bool serverSideEncryption;
-					std::string protocol;
 					std::string pathPrefix;
-					long lagPeriod;
+					std::string protocol;
 					std::string partialSyncPaths;
+					long lagPeriod;
 					std::string ossHealth;
 					std::string indexId;
 					long activeMessages;

sgw/include/alibabacloud/sgw/model/DescribeGatewayNFSClientsRequest.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_SGW_MODEL_DESCRIBEGATEWAYNFSCLIENTSREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYNFSCLIENTSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/sgw/SgwExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sgw
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SGW_EXPORT DescribeGatewayNFSClientsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeGatewayNFSClientsRequest();
+				~DescribeGatewayNFSClientsRequest();
+
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getGatewayId()const;
+				void setGatewayId(const std::string& gatewayId);
+
+            private:
+				int pageNumber_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				int pageSize_;
+				std::string gatewayId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYNFSCLIENTSREQUEST_H_

sgw/include/alibabacloud/sgw/model/DescribeGatewayNFSClientsResult.h

@@ -0,0 +1,76 @@
+/*
+ * 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_SGW_MODEL_DESCRIBEGATEWAYNFSCLIENTSRESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYNFSCLIENTSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/sgw/SgwExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sgw
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SGW_EXPORT DescribeGatewayNFSClientsResult : public ServiceResult
+			{
+			public:
+				struct ClientInfo
+				{
+					bool hasNFSv3;
+					bool hasNFSv40;
+					std::string clientIpAddr;
+					bool hasNFSv41;
+				};
+
+
+				DescribeGatewayNFSClientsResult();
+				explicit DescribeGatewayNFSClientsResult(const std::string &payload);
+				~DescribeGatewayNFSClientsResult();
+				bool getVersion40Enabled()const;
+				int getTotalCount()const;
+				bool getVersion41Enabled()const;
+				std::string getMessage()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<ClientInfo> getClientInfoList()const;
+				bool getVersion3Enabled()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool version40Enabled_;
+				int totalCount_;
+				bool version41Enabled_;
+				std::string message_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<ClientInfo> clientInfoList_;
+				bool version3Enabled_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYNFSCLIENTSRESULT_H_

sgw/include/alibabacloud/sgw/model/DescribeGatewayResult.h

@@ -74,6 +74,7 @@ namespace AlibabaCloud
 				bool getElasticGateway()const;
 				std::string getCommonBuyInstanceId()const;
 				std::string getModel()const;
+				std::string getInnerIpv6Ip()const;
 				std::string getLastErrorKey()const;
 				std::string getLocation()const;
 
@@ -117,6 +118,7 @@ namespace AlibabaCloud
 				bool elasticGateway_;
 				std::string commonBuyInstanceId_;
 				std::string model_;
+				std::string innerIpv6Ip_;
 				std::string lastErrorKey_;
 				std::string location_;
 

sgw/include/alibabacloud/sgw/model/DescribeGatewaysResult.h

@@ -68,6 +68,7 @@ namespace AlibabaCloud
 					bool elasticGateway;
 					std::string commonBuyInstanceId;
 					std::string model;
+					std::string innerIpv6Ip;
 					std::string lastErrorKey;
 					std::string location;
 				};

sgw/include/alibabacloud/sgw/model/DescribeOssBucketInfoResult.h

@@ -44,6 +44,7 @@ namespace AlibabaCloud
 				long getStorageSize()const;
 				bool getIsBackToResource()const;
 				int getPollingInterval()const;
+				bool getIsVersioning()const;
 				std::string getCode()const;
 				bool getSuccess()const;
 
@@ -57,6 +58,7 @@ namespace AlibabaCloud
 				long storageSize_;
 				bool isBackToResource_;
 				int pollingInterval_;
+				bool isVersioning_;
 				std::string code_;
 				bool success_;
 

sgw/include/alibabacloud/sgw/model/DisableGatewayNFSVersionRequest.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_SGW_MODEL_DISABLEGATEWAYNFSVERSIONREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_DISABLEGATEWAYNFSVERSIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/sgw/SgwExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sgw
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SGW_EXPORT DisableGatewayNFSVersionRequest : public RpcServiceRequest
+			{
+
+			public:
+				DisableGatewayNFSVersionRequest();
+				~DisableGatewayNFSVersionRequest();
+
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getNFSVersion()const;
+				void setNFSVersion(const std::string& nFSVersion);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getGatewayId()const;
+				void setGatewayId(const std::string& gatewayId);
+
+            private:
+				std::string accessKeyId_;
+				std::string nFSVersion_;
+				std::string securityToken_;
+				std::string gatewayId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_DISABLEGATEWAYNFSVERSIONREQUEST_H_

sgw/include/alibabacloud/sgw/model/DisableGatewayNFSVersionResult.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_SGW_MODEL_DISABLEGATEWAYNFSVERSIONRESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_DISABLEGATEWAYNFSVERSIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/sgw/SgwExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sgw
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SGW_EXPORT DisableGatewayNFSVersionResult : public ServiceResult
+			{
+			public:
+
+
+				DisableGatewayNFSVersionResult();
+				explicit DisableGatewayNFSVersionResult(const std::string &payload);
+				~DisableGatewayNFSVersionResult();
+				std::string getTaskId()const;
+				std::string getMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string taskId_;
+				std::string message_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_DISABLEGATEWAYNFSVERSIONRESULT_H_

sgw/include/alibabacloud/sgw/model/EnableGatewayIpv6Request.h

@@ -0,0 +1,54 @@
+/*
+ * 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_SGW_MODEL_ENABLEGATEWAYIPV6REQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_ENABLEGATEWAYIPV6REQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/sgw/SgwExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sgw
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SGW_EXPORT EnableGatewayIpv6Request : public RpcServiceRequest
+			{
+
+			public:
+				EnableGatewayIpv6Request();
+				~EnableGatewayIpv6Request();
+
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getGatewayId()const;
+				void setGatewayId(const std::string& gatewayId);
+
+            private:
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string gatewayId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_ENABLEGATEWAYIPV6REQUEST_H_

sgw/include/alibabacloud/sgw/model/EnableGatewayIpv6Result.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_SGW_MODEL_ENABLEGATEWAYIPV6RESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_ENABLEGATEWAYIPV6RESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/sgw/SgwExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sgw
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SGW_EXPORT EnableGatewayIpv6Result : public ServiceResult
+			{
+			public:
+
+
+				EnableGatewayIpv6Result();
+				explicit EnableGatewayIpv6Result(const std::string &payload);
+				~EnableGatewayIpv6Result();
+				std::string getTaskId()const;
+				std::string getMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string taskId_;
+				std::string message_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_ENABLEGATEWAYIPV6RESULT_H_

sgw/include/alibabacloud/sgw/model/ModifyGatewayFileShareWatermarkRequest.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_SGW_MODEL_MODIFYGATEWAYFILESHAREWATERMARKREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_MODIFYGATEWAYFILESHAREWATERMARKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/sgw/SgwExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sgw
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SGW_EXPORT ModifyGatewayFileShareWatermarkRequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifyGatewayFileShareWatermarkRequest();
+				~ModifyGatewayFileShareWatermarkRequest();
+
+				int getWatermark()const;
+				void setWatermark(int watermark);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getIndexId()const;
+				void setIndexId(const std::string& indexId);
+				std::string getGatewayId()const;
+				void setGatewayId(const std::string& gatewayId);
+
+            private:
+				int watermark_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string indexId_;
+				std::string gatewayId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_MODIFYGATEWAYFILESHAREWATERMARKREQUEST_H_

sgw/include/alibabacloud/sgw/model/ModifyGatewayFileShareWatermarkResult.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_SGW_MODEL_MODIFYGATEWAYFILESHAREWATERMARKRESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_MODIFYGATEWAYFILESHAREWATERMARKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/sgw/SgwExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sgw
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SGW_EXPORT ModifyGatewayFileShareWatermarkResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyGatewayFileShareWatermarkResult();
+				explicit ModifyGatewayFileShareWatermarkResult(const std::string &payload);
+				~ModifyGatewayFileShareWatermarkResult();
+				std::string getTaskId()const;
+				std::string getMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string taskId_;
+				std::string message_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_MODIFYGATEWAYFILESHAREWATERMARKRESULT_H_

sgw/include/alibabacloud/sgw/model/OpenSgwServiceRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SGW_MODEL_OPENSGWSERVICEREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_OPENSGWSERVICEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/sgw/SgwExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sgw
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SGW_EXPORT OpenSgwServiceRequest : public RpcServiceRequest
+			{
+
+			public:
+				OpenSgwServiceRequest();
+				~OpenSgwServiceRequest();
+
+
+            private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_OPENSGWSERVICEREQUEST_H_

sgw/include/alibabacloud/sgw/model/OpenSgwServiceResult.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_SGW_MODEL_OPENSGWSERVICERESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_OPENSGWSERVICERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/sgw/SgwExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sgw
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SGW_EXPORT OpenSgwServiceResult : public ServiceResult
+			{
+			public:
+
+
+				OpenSgwServiceResult();
+				explicit OpenSgwServiceResult(const std::string &payload);
+				~OpenSgwServiceResult();
+				std::string getOrderId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string orderId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_OPENSGWSERVICERESULT_H_

sgw/include/alibabacloud/sgw/model/TriggerGatewayRemoteSyncRequest.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_SGW_MODEL_TRIGGERGATEWAYREMOTESYNCREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_TRIGGERGATEWAYREMOTESYNCREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/sgw/SgwExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sgw
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SGW_EXPORT TriggerGatewayRemoteSyncRequest : public RpcServiceRequest
+			{
+
+			public:
+				TriggerGatewayRemoteSyncRequest();
+				~TriggerGatewayRemoteSyncRequest();
+
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getPath()const;
+				void setPath(const std::string& path);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getIndexId()const;
+				void setIndexId(const std::string& indexId);
+				std::string getGatewayId()const;
+				void setGatewayId(const std::string& gatewayId);
+
+            private:
+				std::string accessKeyId_;
+				std::string path_;
+				std::string securityToken_;
+				std::string indexId_;
+				std::string gatewayId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_TRIGGERGATEWAYREMOTESYNCREQUEST_H_

sgw/include/alibabacloud/sgw/model/TriggerGatewayRemoteSyncResult.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_SGW_MODEL_TRIGGERGATEWAYREMOTESYNCRESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_TRIGGERGATEWAYREMOTESYNCRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/sgw/SgwExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sgw
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SGW_EXPORT TriggerGatewayRemoteSyncResult : public ServiceResult
+			{
+			public:
+
+
+				TriggerGatewayRemoteSyncResult();
+				explicit TriggerGatewayRemoteSyncResult(const std::string &payload);
+				~TriggerGatewayRemoteSyncResult();
+				std::string getTaskId()const;
+				std::string getMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string taskId_;
+				std::string message_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_TRIGGERGATEWAYREMOTESYNCRESULT_H_

sgw/include/alibabacloud/sgw/model/UpdateGatewayFileShareRequest.h

@@ -47,6 +47,8 @@ namespace AlibabaCloud
 				void setPollingInterval(int pollingInterval);
 				std::string getReadWriteClientList()const;
 				void setReadWriteClientList(const std::string& readWriteClientList);
+				bool getBypassCacheRead()const;
+				void setBypassCacheRead(bool bypassCacheRead);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
 				int getBackendLimit()const;
@@ -107,6 +109,7 @@ namespace AlibabaCloud
 				std::string readWriteUserList_;
 				int pollingInterval_;
 				std::string readWriteClientList_;
+				bool bypassCacheRead_;
 				std::string accessKeyId_;
 				int backendLimit_;
 				std::string squash_;

sgw/src/SgwClient.cc

@@ -483,6 +483,42 @@ SgwClient::CreateCacheOutcomeCallable SgwClient::createCacheCallable(const Creat
 	return task->get_future();
 }
 
+SgwClient::CreateElasticGatewayPrivateZoneOutcome SgwClient::createElasticGatewayPrivateZone(const CreateElasticGatewayPrivateZoneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateElasticGatewayPrivateZoneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateElasticGatewayPrivateZoneOutcome(CreateElasticGatewayPrivateZoneResult(outcome.result()));
+	else
+		return CreateElasticGatewayPrivateZoneOutcome(outcome.error());
+}
+
+void SgwClient::createElasticGatewayPrivateZoneAsync(const CreateElasticGatewayPrivateZoneRequest& request, const CreateElasticGatewayPrivateZoneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createElasticGatewayPrivateZone(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SgwClient::CreateElasticGatewayPrivateZoneOutcomeCallable SgwClient::createElasticGatewayPrivateZoneCallable(const CreateElasticGatewayPrivateZoneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateElasticGatewayPrivateZoneOutcome()>>(
+			[this, request]()
+			{
+			return this->createElasticGatewayPrivateZone(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SgwClient::CreateExpressSyncOutcome SgwClient::createExpressSync(const CreateExpressSyncRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -771,6 +807,42 @@ SgwClient::CreateStorageBundleOutcomeCallable SgwClient::createStorageBundleCall
 	return task->get_future();
 }
 
+SgwClient::DeleteElasticGatewayPrivateZoneOutcome SgwClient::deleteElasticGatewayPrivateZone(const DeleteElasticGatewayPrivateZoneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteElasticGatewayPrivateZoneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteElasticGatewayPrivateZoneOutcome(DeleteElasticGatewayPrivateZoneResult(outcome.result()));
+	else
+		return DeleteElasticGatewayPrivateZoneOutcome(outcome.error());
+}
+
+void SgwClient::deleteElasticGatewayPrivateZoneAsync(const DeleteElasticGatewayPrivateZoneRequest& request, const DeleteElasticGatewayPrivateZoneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteElasticGatewayPrivateZone(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SgwClient::DeleteElasticGatewayPrivateZoneOutcomeCallable SgwClient::deleteElasticGatewayPrivateZoneCallable(const DeleteElasticGatewayPrivateZoneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteElasticGatewayPrivateZoneOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteElasticGatewayPrivateZone(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SgwClient::DeleteExpressSyncOutcome SgwClient::deleteExpressSync(const DeleteExpressSyncRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2103,6 +2175,42 @@ SgwClient::DescribeGatewayModificationClassesOutcomeCallable SgwClient::describe
 	return task->get_future();
 }
 
+SgwClient::DescribeGatewayNFSClientsOutcome SgwClient::describeGatewayNFSClients(const DescribeGatewayNFSClientsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeGatewayNFSClientsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeGatewayNFSClientsOutcome(DescribeGatewayNFSClientsResult(outcome.result()));
+	else
+		return DescribeGatewayNFSClientsOutcome(outcome.error());
+}
+
+void SgwClient::describeGatewayNFSClientsAsync(const DescribeGatewayNFSClientsRequest& request, const DescribeGatewayNFSClientsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeGatewayNFSClients(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SgwClient::DescribeGatewayNFSClientsOutcomeCallable SgwClient::describeGatewayNFSClientsCallable(const DescribeGatewayNFSClientsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeGatewayNFSClientsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeGatewayNFSClients(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SgwClient::DescribeGatewaySMBUsersOutcome SgwClient::describeGatewaySMBUsers(const DescribeGatewaySMBUsersRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2931,6 +3039,78 @@ SgwClient::DisableGatewayLoggingOutcomeCallable SgwClient::disableGatewayLogging
 	return task->get_future();
 }
 
+SgwClient::DisableGatewayNFSVersionOutcome SgwClient::disableGatewayNFSVersion(const DisableGatewayNFSVersionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DisableGatewayNFSVersionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DisableGatewayNFSVersionOutcome(DisableGatewayNFSVersionResult(outcome.result()));
+	else
+		return DisableGatewayNFSVersionOutcome(outcome.error());
+}
+
+void SgwClient::disableGatewayNFSVersionAsync(const DisableGatewayNFSVersionRequest& request, const DisableGatewayNFSVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, disableGatewayNFSVersion(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SgwClient::DisableGatewayNFSVersionOutcomeCallable SgwClient::disableGatewayNFSVersionCallable(const DisableGatewayNFSVersionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DisableGatewayNFSVersionOutcome()>>(
+			[this, request]()
+			{
+			return this->disableGatewayNFSVersion(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SgwClient::EnableGatewayIpv6Outcome SgwClient::enableGatewayIpv6(const EnableGatewayIpv6Request &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EnableGatewayIpv6Outcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EnableGatewayIpv6Outcome(EnableGatewayIpv6Result(outcome.result()));
+	else
+		return EnableGatewayIpv6Outcome(outcome.error());
+}
+
+void SgwClient::enableGatewayIpv6Async(const EnableGatewayIpv6Request& request, const EnableGatewayIpv6AsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, enableGatewayIpv6(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SgwClient::EnableGatewayIpv6OutcomeCallable SgwClient::enableGatewayIpv6Callable(const EnableGatewayIpv6Request &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EnableGatewayIpv6Outcome()>>(
+			[this, request]()
+			{
+			return this->enableGatewayIpv6(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SgwClient::EnableGatewayLoggingOutcome SgwClient::enableGatewayLogging(const EnableGatewayLoggingRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3327,6 +3507,42 @@ SgwClient::ModifyGatewayFileShareOutcomeCallable SgwClient::modifyGatewayFileSha
 	return task->get_future();
 }
 
+SgwClient::ModifyGatewayFileShareWatermarkOutcome SgwClient::modifyGatewayFileShareWatermark(const ModifyGatewayFileShareWatermarkRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyGatewayFileShareWatermarkOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyGatewayFileShareWatermarkOutcome(ModifyGatewayFileShareWatermarkResult(outcome.result()));
+	else
+		return ModifyGatewayFileShareWatermarkOutcome(outcome.error());
+}
+
+void SgwClient::modifyGatewayFileShareWatermarkAsync(const ModifyGatewayFileShareWatermarkRequest& request, const ModifyGatewayFileShareWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyGatewayFileShareWatermark(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SgwClient::ModifyGatewayFileShareWatermarkOutcomeCallable SgwClient::modifyGatewayFileShareWatermarkCallable(const ModifyGatewayFileShareWatermarkRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyGatewayFileShareWatermarkOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyGatewayFileShareWatermark(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SgwClient::ModifyStorageBundleOutcome SgwClient::modifyStorageBundle(const ModifyStorageBundleRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3363,6 +3579,42 @@ SgwClient::ModifyStorageBundleOutcomeCallable SgwClient::modifyStorageBundleCall
 	return task->get_future();
 }
 
+SgwClient::OpenSgwServiceOutcome SgwClient::openSgwService(const OpenSgwServiceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return OpenSgwServiceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return OpenSgwServiceOutcome(OpenSgwServiceResult(outcome.result()));
+	else
+		return OpenSgwServiceOutcome(outcome.error());
+}
+
+void SgwClient::openSgwServiceAsync(const OpenSgwServiceRequest& request, const OpenSgwServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, openSgwService(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SgwClient::OpenSgwServiceOutcomeCallable SgwClient::openSgwServiceCallable(const OpenSgwServiceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<OpenSgwServiceOutcome()>>(
+			[this, request]()
+			{
+			return this->openSgwService(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SgwClient::OperateGatewayOutcome SgwClient::operateGateway(const OperateGatewayRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3939,6 +4191,42 @@ SgwClient::TagResourcesOutcomeCallable SgwClient::tagResourcesCallable(const Tag
 	return task->get_future();
 }
 
+SgwClient::TriggerGatewayRemoteSyncOutcome SgwClient::triggerGatewayRemoteSync(const TriggerGatewayRemoteSyncRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return TriggerGatewayRemoteSyncOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return TriggerGatewayRemoteSyncOutcome(TriggerGatewayRemoteSyncResult(outcome.result()));
+	else
+		return TriggerGatewayRemoteSyncOutcome(outcome.error());
+}
+
+void SgwClient::triggerGatewayRemoteSyncAsync(const TriggerGatewayRemoteSyncRequest& request, const TriggerGatewayRemoteSyncAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, triggerGatewayRemoteSync(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SgwClient::TriggerGatewayRemoteSyncOutcomeCallable SgwClient::triggerGatewayRemoteSyncCallable(const TriggerGatewayRemoteSyncRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<TriggerGatewayRemoteSyncOutcome()>>(
+			[this, request]()
+			{
+			return this->triggerGatewayRemoteSync(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SgwClient::UntagResourcesOutcome SgwClient::untagResources(const UntagResourcesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

sgw/src/model/CreateElasticGatewayPrivateZoneRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/sgw/model/CreateElasticGatewayPrivateZoneRequest.h>
+
+using AlibabaCloud::Sgw::Model::CreateElasticGatewayPrivateZoneRequest;
+
+CreateElasticGatewayPrivateZoneRequest::CreateElasticGatewayPrivateZoneRequest() :
+	RpcServiceRequest("sgw", "2018-05-11", "CreateElasticGatewayPrivateZone")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateElasticGatewayPrivateZoneRequest::~CreateElasticGatewayPrivateZoneRequest()
+{}
+
+std::string CreateElasticGatewayPrivateZoneRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CreateElasticGatewayPrivateZoneRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string CreateElasticGatewayPrivateZoneRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void CreateElasticGatewayPrivateZoneRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string CreateElasticGatewayPrivateZoneRequest::getGatewayId()const
+{
+	return gatewayId_;
+}
+
+void CreateElasticGatewayPrivateZoneRequest::setGatewayId(const std::string& gatewayId)
+{
+	gatewayId_ = gatewayId;
+	setParameter("GatewayId", gatewayId);
+}
+

sgw/src/model/CreateElasticGatewayPrivateZoneResult.cc

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

sgw/src/model/CreateGatewayFileShareRequest.cc

@@ -60,6 +60,17 @@ void CreateGatewayFileShareRequest::setReadWriteClientList(const std::string& re
 	setParameter("ReadWriteClientList", readWriteClientList);
 }
 
+bool CreateGatewayFileShareRequest::getBypassCacheRead()const
+{
+	return bypassCacheRead_;
+}
+
+void CreateGatewayFileShareRequest::setBypassCacheRead(bool bypassCacheRead)
+{
+	bypassCacheRead_ = bypassCacheRead;
+	setParameter("BypassCacheRead", bypassCacheRead ? "true" : "false");
+}
+
 int CreateGatewayFileShareRequest::getBackendLimit()const
 {
 	return backendLimit_;
@@ -368,6 +379,17 @@ void CreateGatewayFileShareRequest::setAccessKeyId(const std::string& accessKeyI
 	setParameter("AccessKeyId", accessKeyId);
 }
 
+std::string CreateGatewayFileShareRequest::getServerSideAlgorithm()const
+{
+	return serverSideAlgorithm_;
+}
+
+void CreateGatewayFileShareRequest::setServerSideAlgorithm(const std::string& serverSideAlgorithm)
+{
+	serverSideAlgorithm_ = serverSideAlgorithm;
+	setParameter("ServerSideAlgorithm", serverSideAlgorithm);
+}
+
 std::string CreateGatewayFileShareRequest::getServerSideCmk()const
 {
 	return serverSideCmk_;

sgw/src/model/CreateGatewayFileShareResult.cc

@@ -39,14 +39,14 @@ void CreateGatewayFileShareResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
-	if(!value["Code"].isNull())
-		code_ = value["Code"].asString();
-	if(!value["Message"].isNull())
-		message_ = value["Message"].asString();
 	if(!value["TaskId"].isNull())
 		taskId_ = value["TaskId"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 

sgw/src/model/DeleteElasticGatewayPrivateZoneRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/sgw/model/DeleteElasticGatewayPrivateZoneRequest.h>
+
+using AlibabaCloud::Sgw::Model::DeleteElasticGatewayPrivateZoneRequest;
+
+DeleteElasticGatewayPrivateZoneRequest::DeleteElasticGatewayPrivateZoneRequest() :
+	RpcServiceRequest("sgw", "2018-05-11", "DeleteElasticGatewayPrivateZone")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteElasticGatewayPrivateZoneRequest::~DeleteElasticGatewayPrivateZoneRequest()
+{}
+
+std::string DeleteElasticGatewayPrivateZoneRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DeleteElasticGatewayPrivateZoneRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DeleteElasticGatewayPrivateZoneRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DeleteElasticGatewayPrivateZoneRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DeleteElasticGatewayPrivateZoneRequest::getGatewayId()const
+{
+	return gatewayId_;
+}
+
+void DeleteElasticGatewayPrivateZoneRequest::setGatewayId(const std::string& gatewayId)
+{
+	gatewayId_ = gatewayId;
+	setParameter("GatewayId", gatewayId);
+}
+

sgw/src/model/DeleteElasticGatewayPrivateZoneResult.cc

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

sgw/src/model/DeleteGatewayRequest.cc

@@ -38,6 +38,17 @@ void DeleteGatewayRequest::setAccessKeyId(const std::string& accessKeyId)
 	setParameter("AccessKeyId", accessKeyId);
 }
 
+std::string DeleteGatewayRequest::getReasonDetail()const
+{
+	return reasonDetail_;
+}
+
+void DeleteGatewayRequest::setReasonDetail(const std::string& reasonDetail)
+{
+	reasonDetail_ = reasonDetail;
+	setParameter("ReasonDetail", reasonDetail);
+}
+
 std::string DeleteGatewayRequest::getSecurityToken()const
 {
 	return securityToken_;
@@ -60,3 +71,14 @@ void DeleteGatewayRequest::setGatewayId(const std::string& gatewayId)
 	setParameter("GatewayId", gatewayId);
 }
 
+std::string DeleteGatewayRequest::getReasonType()const
+{
+	return reasonType_;
+}
+
+void DeleteGatewayRequest::setReasonType(const std::string& reasonType)
+{
+	reasonType_ = reasonType;
+	setParameter("ReasonType", reasonType);
+}
+

sgw/src/model/DescribeGatewayCachesResult.cc

@@ -65,6 +65,8 @@ void DescribeGatewayCachesResult::parse(const std::string &payload)
 			cachesObject.performanceLevel = valueCachesCache["PerformanceLevel"].asString();
 		if(!valueCachesCache["BuyURL"].isNull())
 			cachesObject.buyURL = valueCachesCache["BuyURL"].asString();
+		if(!valueCachesCache["SubscriptionInstanceId"].isNull())
+			cachesObject.subscriptionInstanceId = valueCachesCache["SubscriptionInstanceId"].asString();
 		caches_.push_back(cachesObject);
 	}
 	if(!value["Success"].isNull())

sgw/src/model/DescribeGatewayCapacityLimitResult.cc

@@ -39,18 +39,18 @@ void DescribeGatewayCapacityLimitResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
-	if(!value["Code"].isNull())
-		code_ = value["Code"].asString();
-	if(!value["Message"].isNull())
-		message_ = value["Message"].asString();
-	if(!value["FileNumber"].isNull())
-		fileNumber_ = std::stol(value["FileNumber"].asString());
 	if(!value["FileSystemSizeInTB"].isNull())
 		fileSystemSizeInTB_ = std::stol(value["FileSystemSizeInTB"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
 	if(!value["IsMetadataSeparate"].isNull())
 		isMetadataSeparate_ = value["IsMetadataSeparate"].asString() == "true";
+	if(!value["FileNumber"].isNull())
+		fileNumber_ = std::stol(value["FileNumber"].asString());
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 
@@ -64,9 +64,9 @@ std::string DescribeGatewayCapacityLimitResult::getMessage()const
 	return message_;
 }
 
-std::string DescribeGatewayCapacityLimitResult::getCode()const
+bool DescribeGatewayCapacityLimitResult::getIsMetadataSeparate()const
 {
-	return code_;
+	return isMetadataSeparate_;
 }
 
 long DescribeGatewayCapacityLimitResult::getFileNumber()const
@@ -74,9 +74,9 @@ long DescribeGatewayCapacityLimitResult::getFileNumber()const
 	return fileNumber_;
 }
 
-bool DescribeGatewayCapacityLimitResult::getIsMetadataSeparate()const
+std::string DescribeGatewayCapacityLimitResult::getCode()const
 {
-	return isMetadataSeparate_;
+	return code_;
 }
 
 bool DescribeGatewayCapacityLimitResult::getSuccess()const

sgw/src/model/DescribeGatewayFileSharesResult.cc

@@ -43,144 +43,154 @@ void DescribeGatewayFileSharesResult::parse(const std::string &payload)
 	for (auto valueFileSharesFileShare : allFileSharesNode)
 	{
 		FileShare fileSharesObject;
-		if(!valueFileSharesFileShare["Name"].isNull())
-			fileSharesObject.name = valueFileSharesFileShare["Name"].asString();
-		if(!valueFileSharesFileShare["DiskId"].isNull())
-			fileSharesObject.diskId = valueFileSharesFileShare["DiskId"].asString();
-		if(!valueFileSharesFileShare["DiskType"].isNull())
-			fileSharesObject.diskType = valueFileSharesFileShare["DiskType"].asString();
-		if(!valueFileSharesFileShare["Protocol"].isNull())
-			fileSharesObject.protocol = valueFileSharesFileShare["Protocol"].asString();
-		if(!valueFileSharesFileShare["Size"].isNull())
-			fileSharesObject.size = std::stol(valueFileSharesFileShare["Size"].asString());
-		if(!valueFileSharesFileShare["Enabled"].isNull())
-			fileSharesObject.enabled = valueFileSharesFileShare["Enabled"].asString() == "true";
-		if(!valueFileSharesFileShare["State"].isNull())
-			fileSharesObject.state = valueFileSharesFileShare["State"].asString();
-		if(!valueFileSharesFileShare["TotalUpload"].isNull())
-			fileSharesObject.totalUpload = std::stol(valueFileSharesFileShare["TotalUpload"].asString());
-		if(!valueFileSharesFileShare["TotalDownload"].isNull())
-			fileSharesObject.totalDownload = std::stol(valueFileSharesFileShare["TotalDownload"].asString());
-		if(!valueFileSharesFileShare["OssBucketName"].isNull())
-			fileSharesObject.ossBucketName = valueFileSharesFileShare["OssBucketName"].asString();
-		if(!valueFileSharesFileShare["OssEndpoint"].isNull())
-			fileSharesObject.ossEndpoint = valueFileSharesFileShare["OssEndpoint"].asString();
-		if(!valueFileSharesFileShare["OssBucketSsl"].isNull())
-			fileSharesObject.ossBucketSsl = valueFileSharesFileShare["OssBucketSsl"].asString() == "true";
-		if(!valueFileSharesFileShare["LocalPath"].isNull())
-			fileSharesObject.localPath = valueFileSharesFileShare["LocalPath"].asString();
-		if(!valueFileSharesFileShare["CacheMode"].isNull())
-			fileSharesObject.cacheMode = valueFileSharesFileShare["CacheMode"].asString();
-		if(!valueFileSharesFileShare["Address"].isNull())
-			fileSharesObject.address = valueFileSharesFileShare["Address"].asString();
 		if(!valueFileSharesFileShare["SerialNumber"].isNull())
 			fileSharesObject.serialNumber = valueFileSharesFileShare["SerialNumber"].asString();
+		if(!valueFileSharesFileShare["ClientSideCmk"].isNull())
+			fileSharesObject.clientSideCmk = valueFileSharesFileShare["ClientSideCmk"].asString();
+		if(!valueFileSharesFileShare["PartialSyncPaths"].isNull())
+			fileSharesObject.partialSyncPaths = valueFileSharesFileShare["PartialSyncPaths"].asString();
+		if(!valueFileSharesFileShare["PathPrefix"].isNull())
+			fileSharesObject.pathPrefix = valueFileSharesFileShare["PathPrefix"].asString();
+		if(!valueFileSharesFileShare["BucketsStub"].isNull())
+			fileSharesObject.bucketsStub = valueFileSharesFileShare["BucketsStub"].asString() == "true";
+		if(!valueFileSharesFileShare["UploadQueue"].isNull())
+			fileSharesObject.uploadQueue = std::stol(valueFileSharesFileShare["UploadQueue"].asString());
+		if(!valueFileSharesFileShare["DiskId"].isNull())
+			fileSharesObject.diskId = valueFileSharesFileShare["DiskId"].asString();
+		if(!valueFileSharesFileShare["OssUsed"].isNull())
+			fileSharesObject.ossUsed = std::stol(valueFileSharesFileShare["OssUsed"].asString());
+		if(!valueFileSharesFileShare["DownloadQueue"].isNull())
+			fileSharesObject.downloadQueue = std::stol(valueFileSharesFileShare["DownloadQueue"].asString());
+		if(!valueFileSharesFileShare["ActiveMessages"].isNull())
+			fileSharesObject.activeMessages = std::stol(valueFileSharesFileShare["ActiveMessages"].asString());
 		if(!valueFileSharesFileShare["IndexId"].isNull())
 			fileSharesObject.indexId = valueFileSharesFileShare["IndexId"].asString();
-		if(!valueFileSharesFileShare["RemoteSync"].isNull())
-			fileSharesObject.remoteSync = valueFileSharesFileShare["RemoteSync"].asString() == "true";
-		if(!valueFileSharesFileShare["PollingInterval"].isNull())
-			fileSharesObject.pollingInterval = std::stoi(valueFileSharesFileShare["PollingInterval"].asString());
-		if(!valueFileSharesFileShare["IgnoreDelete"].isNull())
-			fileSharesObject.ignoreDelete = valueFileSharesFileShare["IgnoreDelete"].asString() == "true";
+		if(!valueFileSharesFileShare["MnsHealth"].isNull())
+			fileSharesObject.mnsHealth = valueFileSharesFileShare["MnsHealth"].asString();
+		if(!valueFileSharesFileShare["AccessBasedEnumeration"].isNull())
+			fileSharesObject.accessBasedEnumeration = valueFileSharesFileShare["AccessBasedEnumeration"].asString() == "true";
+		if(!valueFileSharesFileShare["DownloadRate"].isNull())
+			fileSharesObject.downloadRate = std::stol(valueFileSharesFileShare["DownloadRate"].asString());
 		if(!valueFileSharesFileShare["FeLimit"].isNull())
 			fileSharesObject.feLimit = std::stoi(valueFileSharesFileShare["FeLimit"].asString());
-		if(!valueFileSharesFileShare["BeLimit"].isNull())
-			fileSharesObject.beLimit = std::stoi(valueFileSharesFileShare["BeLimit"].asString());
+		if(!valueFileSharesFileShare["SupportArchive"].isNull())
+			fileSharesObject.supportArchive = valueFileSharesFileShare["SupportArchive"].asString() == "true";
+		if(!valueFileSharesFileShare["OssEndpoint"].isNull())
+			fileSharesObject.ossEndpoint = valueFileSharesFileShare["OssEndpoint"].asString();
+		if(!valueFileSharesFileShare["OssHealth"].isNull())
+			fileSharesObject.ossHealth = valueFileSharesFileShare["OssHealth"].asString();
+		if(!valueFileSharesFileShare["OutRate"].isNull())
+			fileSharesObject.outRate = std::stol(valueFileSharesFileShare["OutRate"].asString());
+		if(!valueFileSharesFileShare["ServerSideCmk"].isNull())
+			fileSharesObject.serverSideCmk = valueFileSharesFileShare["ServerSideCmk"].asString();
+		if(!valueFileSharesFileShare["RwClientList"].isNull())
+			fileSharesObject.rwClientList = valueFileSharesFileShare["RwClientList"].asString();
+		if(!valueFileSharesFileShare["State"].isNull())
+			fileSharesObject.state = valueFileSharesFileShare["State"].asString();
+		if(!valueFileSharesFileShare["Protocol"].isNull())
+			fileSharesObject.protocol = valueFileSharesFileShare["Protocol"].asString();
+		if(!valueFileSharesFileShare["OssBucketSsl"].isNull())
+			fileSharesObject.ossBucketSsl = valueFileSharesFileShare["OssBucketSsl"].asString() == "true";
+		if(!valueFileSharesFileShare["DownloadLimit"].isNull())
+			fileSharesObject.downloadLimit = std::stoi(valueFileSharesFileShare["DownloadLimit"].asString());
 		if(!valueFileSharesFileShare["InPlace"].isNull())
 			fileSharesObject.inPlace = valueFileSharesFileShare["InPlace"].asString() == "true";
-		if(!valueFileSharesFileShare["Browsable"].isNull())
-			fileSharesObject.browsable = valueFileSharesFileShare["Browsable"].asString() == "true";
+		if(!valueFileSharesFileShare["RemoteSync"].isNull())
+			fileSharesObject.remoteSync = valueFileSharesFileShare["RemoteSync"].asString() == "true";
+		if(!valueFileSharesFileShare["FileNumLimit"].isNull())
+			fileSharesObject.fileNumLimit = std::stol(valueFileSharesFileShare["FileNumLimit"].asString());
 		if(!valueFileSharesFileShare["Squash"].isNull())
 			fileSharesObject.squash = valueFileSharesFileShare["Squash"].asString();
-		if(!valueFileSharesFileShare["RwUserList"].isNull())
-			fileSharesObject.rwUserList = valueFileSharesFileShare["RwUserList"].asString();
-		if(!valueFileSharesFileShare["RoUserList"].isNull())
-			fileSharesObject.roUserList = valueFileSharesFileShare["RoUserList"].asString();
-		if(!valueFileSharesFileShare["RwClientList"].isNull())
-			fileSharesObject.rwClientList = valueFileSharesFileShare["RwClientList"].asString();
-		if(!valueFileSharesFileShare["RoClientList"].isNull())
-			fileSharesObject.roClientList = valueFileSharesFileShare["RoClientList"].asString();
-		if(!valueFileSharesFileShare["OssUsed"].isNull())
-			fileSharesObject.ossUsed = std::stol(valueFileSharesFileShare["OssUsed"].asString());
-		if(!valueFileSharesFileShare["Used"].isNull())
-			fileSharesObject.used = std::stol(valueFileSharesFileShare["Used"].asString());
-		if(!valueFileSharesFileShare["InRate"].isNull())
-			fileSharesObject.inRate = std::stol(valueFileSharesFileShare["InRate"].asString());
-		if(!valueFileSharesFileShare["OutRate"].isNull())
-			fileSharesObject.outRate = std::stol(valueFileSharesFileShare["OutRate"].asString());
-		if(!valueFileSharesFileShare["LagPeriod"].isNull())
-			fileSharesObject.lagPeriod = std::stol(valueFileSharesFileShare["LagPeriod"].asString());
-		if(!valueFileSharesFileShare["DirectIO"].isNull())
-			fileSharesObject.directIO = valueFileSharesFileShare["DirectIO"].asString() == "true";
 		if(!valueFileSharesFileShare["NfsFullPath"].isNull())
 			fileSharesObject.nfsFullPath = valueFileSharesFileShare["NfsFullPath"].asString();
-		if(!valueFileSharesFileShare["FileNumLimit"].isNull())
-			fileSharesObject.fileNumLimit = std::stol(valueFileSharesFileShare["FileNumLimit"].asString());
-		if(!valueFileSharesFileShare["FsSizeLimit"].isNull())
-			fileSharesObject.fsSizeLimit = std::stol(valueFileSharesFileShare["FsSizeLimit"].asString());
+		if(!valueFileSharesFileShare["RemainingMetaSpace"].isNull())
+			fileSharesObject.remainingMetaSpace = std::stol(valueFileSharesFileShare["RemainingMetaSpace"].asString());
+		if(!valueFileSharesFileShare["TransferAcceleration"].isNull())
+			fileSharesObject.transferAcceleration = valueFileSharesFileShare["TransferAcceleration"].asString() == "true";
+		if(!valueFileSharesFileShare["Size"].isNull())
+			fileSharesObject.size = std::stol(valueFileSharesFileShare["Size"].asString());
 		if(!valueFileSharesFileShare["ServerSideEncryption"].isNull())
 			fileSharesObject.serverSideEncryption = valueFileSharesFileShare["ServerSideEncryption"].asString() == "true";
-		if(!valueFileSharesFileShare["ServerSideCmk"].isNull())
-			fileSharesObject.serverSideCmk = valueFileSharesFileShare["ServerSideCmk"].asString();
+		if(!valueFileSharesFileShare["WindowsAcl"].isNull())
+			fileSharesObject.windowsAcl = valueFileSharesFileShare["WindowsAcl"].asString() == "true";
+		if(!valueFileSharesFileShare["RemoteSyncDownload"].isNull())
+			fileSharesObject.remoteSyncDownload = valueFileSharesFileShare["RemoteSyncDownload"].asString() == "true";
 		if(!valueFileSharesFileShare["ClientSideEncryption"].isNull())
 			fileSharesObject.clientSideEncryption = valueFileSharesFileShare["ClientSideEncryption"].asString() == "true";
-		if(!valueFileSharesFileShare["ClientSideCmk"].isNull())
-			fileSharesObject.clientSideCmk = valueFileSharesFileShare["ClientSideCmk"].asString();
+		if(!valueFileSharesFileShare["BucketInfos"].isNull())
+			fileSharesObject.bucketInfos = valueFileSharesFileShare["BucketInfos"].asString();
+		if(!valueFileSharesFileShare["NfsV4Optimization"].isNull())
+			fileSharesObject.nfsV4Optimization = valueFileSharesFileShare["NfsV4Optimization"].asString() == "true";
+		if(!valueFileSharesFileShare["TotalUpload"].isNull())
+			fileSharesObject.totalUpload = std::stol(valueFileSharesFileShare["TotalUpload"].asString());
+		if(!valueFileSharesFileShare["DiskType"].isNull())
+			fileSharesObject.diskType = valueFileSharesFileShare["DiskType"].asString();
+		if(!valueFileSharesFileShare["Used"].isNull())
+			fileSharesObject.used = std::stol(valueFileSharesFileShare["Used"].asString());
+		if(!valueFileSharesFileShare["IgnoreDelete"].isNull())
+			fileSharesObject.ignoreDelete = valueFileSharesFileShare["IgnoreDelete"].asString() == "true";
+		if(!valueFileSharesFileShare["RoUserList"].isNull())
+			fileSharesObject.roUserList = valueFileSharesFileShare["RoUserList"].asString();
+		if(!valueFileSharesFileShare["FsSizeLimit"].isNull())
+			fileSharesObject.fsSizeLimit = std::stol(valueFileSharesFileShare["FsSizeLimit"].asString());
+		if(!valueFileSharesFileShare["TotalDownload"].isNull())
+			fileSharesObject.totalDownload = std::stol(valueFileSharesFileShare["TotalDownload"].asString());
+		if(!valueFileSharesFileShare["Enabled"].isNull())
+			fileSharesObject.enabled = valueFileSharesFileShare["Enabled"].asString() == "true";
+		if(!valueFileSharesFileShare["HighWatermark"].isNull())
+			fileSharesObject.highWatermark = std::stoi(valueFileSharesFileShare["HighWatermark"].asString());
 		if(!valueFileSharesFileShare["KmsRotatePeriod"].isNull())
 			fileSharesObject.kmsRotatePeriod = valueFileSharesFileShare["KmsRotatePeriod"].asString();
-		if(!valueFileSharesFileShare["OssHealth"].isNull())
-			fileSharesObject.ossHealth = valueFileSharesFileShare["OssHealth"].asString();
-		if(!valueFileSharesFileShare["PathPrefix"].isNull())
-			fileSharesObject.pathPrefix = valueFileSharesFileShare["PathPrefix"].asString();
-		if(!valueFileSharesFileShare["FastReclaim"].isNull())
-			fileSharesObject.fastReclaim = valueFileSharesFileShare["FastReclaim"].asString() == "true";
-		if(!valueFileSharesFileShare["SupportArchive"].isNull())
-			fileSharesObject.supportArchive = valueFileSharesFileShare["SupportArchive"].asString() == "true";
-		if(!valueFileSharesFileShare["RemainingMetaSpace"].isNull())
-			fileSharesObject.remainingMetaSpace = std::stol(valueFileSharesFileShare["RemainingMetaSpace"].asString());
-		if(!valueFileSharesFileShare["MnsHealth"].isNull())
-			fileSharesObject.mnsHealth = valueFileSharesFileShare["MnsHealth"].asString();
+		if(!valueFileSharesFileShare["Address"].isNull())
+			fileSharesObject.address = valueFileSharesFileShare["Address"].asString();
+		if(!valueFileSharesFileShare["PollingInterval"].isNull())
+			fileSharesObject.pollingInterval = std::stoi(valueFileSharesFileShare["PollingInterval"].asString());
+		if(!valueFileSharesFileShare["Name"].isNull())
+			fileSharesObject.name = valueFileSharesFileShare["Name"].asString();
+		if(!valueFileSharesFileShare["OssBucketName"].isNull())
+			fileSharesObject.ossBucketName = valueFileSharesFileShare["OssBucketName"].asString();
 		if(!valueFileSharesFileShare["ExpressSyncId"].isNull())
 			fileSharesObject.expressSyncId = valueFileSharesFileShare["ExpressSyncId"].asString();
-		if(!valueFileSharesFileShare["WindowsAcl"].isNull())
-			fileSharesObject.windowsAcl = valueFileSharesFileShare["WindowsAcl"].asString() == "true";
-		if(!valueFileSharesFileShare["AccessBasedEnumeration"].isNull())
-			fileSharesObject.accessBasedEnumeration = valueFileSharesFileShare["AccessBasedEnumeration"].asString() == "true";
-		if(!valueFileSharesFileShare["NfsV4Optimization"].isNull())
-			fileSharesObject.nfsV4Optimization = valueFileSharesFileShare["NfsV4Optimization"].asString() == "true";
-		if(!valueFileSharesFileShare["BucketsStub"].isNull())
-			fileSharesObject.bucketsStub = valueFileSharesFileShare["BucketsStub"].asString() == "true";
-		if(!valueFileSharesFileShare["BucketInfos"].isNull())
-			fileSharesObject.bucketInfos = valueFileSharesFileShare["BucketInfos"].asString();
-		if(!valueFileSharesFileShare["ObsoleteBuckets"].isNull())
-			fileSharesObject.obsoleteBuckets = valueFileSharesFileShare["ObsoleteBuckets"].asString();
-		if(!valueFileSharesFileShare["TransferAcceleration"].isNull())
-			fileSharesObject.transferAcceleration = valueFileSharesFileShare["TransferAcceleration"].asString() == "true";
-		if(!valueFileSharesFileShare["DownloadLimit"].isNull())
-			fileSharesObject.downloadLimit = std::stoi(valueFileSharesFileShare["DownloadLimit"].asString());
-		if(!valueFileSharesFileShare["RemoteSyncDownload"].isNull())
-			fileSharesObject.remoteSyncDownload = valueFileSharesFileShare["RemoteSyncDownload"].asString() == "true";
-		if(!valueFileSharesFileShare["PartialSyncPaths"].isNull())
-			fileSharesObject.partialSyncPaths = valueFileSharesFileShare["PartialSyncPaths"].asString();
+		if(!valueFileSharesFileShare["LagPeriod"].isNull())
+			fileSharesObject.lagPeriod = std::stol(valueFileSharesFileShare["LagPeriod"].asString());
+		if(!valueFileSharesFileShare["DirectIO"].isNull())
+			fileSharesObject.directIO = valueFileSharesFileShare["DirectIO"].asString() == "true";
+		if(!valueFileSharesFileShare["CacheMode"].isNull())
+			fileSharesObject.cacheMode = valueFileSharesFileShare["CacheMode"].asString();
+		if(!valueFileSharesFileShare["InRate"].isNull())
+			fileSharesObject.inRate = std::stol(valueFileSharesFileShare["InRate"].asString());
+		if(!valueFileSharesFileShare["LowWatermark"].isNull())
+			fileSharesObject.lowWatermark = std::stoi(valueFileSharesFileShare["LowWatermark"].asString());
 		if(!valueFileSharesFileShare["SyncProgress"].isNull())
 			fileSharesObject.syncProgress = std::stoi(valueFileSharesFileShare["SyncProgress"].asString());
-		if(!valueFileSharesFileShare["UploadQueue"].isNull())
-			fileSharesObject.uploadQueue = std::stol(valueFileSharesFileShare["UploadQueue"].asString());
-		if(!valueFileSharesFileShare["DownloadQueue"].isNull())
-			fileSharesObject.downloadQueue = std::stol(valueFileSharesFileShare["DownloadQueue"].asString());
-		if(!valueFileSharesFileShare["DownloadRate"].isNull())
-			fileSharesObject.downloadRate = std::stol(valueFileSharesFileShare["DownloadRate"].asString());
-		if(!valueFileSharesFileShare["ActiveMessages"].isNull())
-			fileSharesObject.activeMessages = std::stol(valueFileSharesFileShare["ActiveMessages"].asString());
+		if(!valueFileSharesFileShare["ServerSideAlgorithm"].isNull())
+			fileSharesObject.serverSideAlgorithm = valueFileSharesFileShare["ServerSideAlgorithm"].asString();
+		if(!valueFileSharesFileShare["ObsoleteBuckets"].isNull())
+			fileSharesObject.obsoleteBuckets = valueFileSharesFileShare["ObsoleteBuckets"].asString();
+		if(!valueFileSharesFileShare["BeLimit"].isNull())
+			fileSharesObject.beLimit = std::stoi(valueFileSharesFileShare["BeLimit"].asString());
+		if(!valueFileSharesFileShare["LocalPath"].isNull())
+			fileSharesObject.localPath = valueFileSharesFileShare["LocalPath"].asString();
+		if(!valueFileSharesFileShare["RoClientList"].isNull())
+			fileSharesObject.roClientList = valueFileSharesFileShare["RoClientList"].asString();
+		if(!valueFileSharesFileShare["RwUserList"].isNull())
+			fileSharesObject.rwUserList = valueFileSharesFileShare["RwUserList"].asString();
+		if(!valueFileSharesFileShare["FastReclaim"].isNull())
+			fileSharesObject.fastReclaim = valueFileSharesFileShare["FastReclaim"].asString() == "true";
+		if(!valueFileSharesFileShare["Browsable"].isNull())
+			fileSharesObject.browsable = valueFileSharesFileShare["Browsable"].asString() == "true";
+		if(!valueFileSharesFileShare["Throttling"].isNull())
+			fileSharesObject.throttling = valueFileSharesFileShare["Throttling"].asString() == "true";
+		if(!valueFileSharesFileShare["BypassCacheRead"].isNull())
+			fileSharesObject.bypassCacheRead = valueFileSharesFileShare["BypassCacheRead"].asString() == "true";
 		fileShares_.push_back(fileSharesObject);
 	}
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
-	if(!value["Code"].isNull())
-		code_ = value["Code"].asString();
 	if(!value["Message"].isNull())
 		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 

sgw/src/model/DescribeGatewayNFSClientsRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/sgw/model/DescribeGatewayNFSClientsRequest.h>
+
+using AlibabaCloud::Sgw::Model::DescribeGatewayNFSClientsRequest;
+
+DescribeGatewayNFSClientsRequest::DescribeGatewayNFSClientsRequest() :
+	RpcServiceRequest("sgw", "2018-05-11", "DescribeGatewayNFSClients")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeGatewayNFSClientsRequest::~DescribeGatewayNFSClientsRequest()
+{}
+
+int DescribeGatewayNFSClientsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeGatewayNFSClientsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DescribeGatewayNFSClientsRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeGatewayNFSClientsRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeGatewayNFSClientsRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeGatewayNFSClientsRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+int DescribeGatewayNFSClientsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeGatewayNFSClientsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string DescribeGatewayNFSClientsRequest::getGatewayId()const
+{
+	return gatewayId_;
+}
+
+void DescribeGatewayNFSClientsRequest::setGatewayId(const std::string& gatewayId)
+{
+	gatewayId_ = gatewayId;
+	setParameter("GatewayId", gatewayId);
+}
+

sgw/src/model/DescribeGatewayNFSClientsResult.cc

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/sgw/model/DescribeGatewayNFSClientsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Sgw;
+using namespace AlibabaCloud::Sgw::Model;
+
+DescribeGatewayNFSClientsResult::DescribeGatewayNFSClientsResult() :
+	ServiceResult()
+{}
+
+DescribeGatewayNFSClientsResult::DescribeGatewayNFSClientsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeGatewayNFSClientsResult::~DescribeGatewayNFSClientsResult()
+{}
+
+void DescribeGatewayNFSClientsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allClientInfoListNode = value["ClientInfoList"]["ClientInfo"];
+	for (auto valueClientInfoListClientInfo : allClientInfoListNode)
+	{
+		ClientInfo clientInfoListObject;
+		if(!valueClientInfoListClientInfo["ClientIpAddr"].isNull())
+			clientInfoListObject.clientIpAddr = valueClientInfoListClientInfo["ClientIpAddr"].asString();
+		if(!valueClientInfoListClientInfo["HasNFSv3"].isNull())
+			clientInfoListObject.hasNFSv3 = valueClientInfoListClientInfo["HasNFSv3"].asString() == "true";
+		if(!valueClientInfoListClientInfo["HasNFSv40"].isNull())
+			clientInfoListObject.hasNFSv40 = valueClientInfoListClientInfo["HasNFSv40"].asString() == "true";
+		if(!valueClientInfoListClientInfo["HasNFSv41"].isNull())
+			clientInfoListObject.hasNFSv41 = valueClientInfoListClientInfo["HasNFSv41"].asString() == "true";
+		clientInfoList_.push_back(clientInfoListObject);
+	}
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["Version3Enabled"].isNull())
+		version3Enabled_ = value["Version3Enabled"].asString() == "true";
+	if(!value["Version40Enabled"].isNull())
+		version40Enabled_ = value["Version40Enabled"].asString() == "true";
+	if(!value["Version41Enabled"].isNull())
+		version41Enabled_ = value["Version41Enabled"].asString() == "true";
+
+}
+
+bool DescribeGatewayNFSClientsResult::getVersion40Enabled()const
+{
+	return version40Enabled_;
+}
+
+int DescribeGatewayNFSClientsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+bool DescribeGatewayNFSClientsResult::getVersion41Enabled()const
+{
+	return version41Enabled_;
+}
+
+std::string DescribeGatewayNFSClientsResult::getMessage()const
+{
+	return message_;
+}
+
+int DescribeGatewayNFSClientsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeGatewayNFSClientsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeGatewayNFSClientsResult::ClientInfo> DescribeGatewayNFSClientsResult::getClientInfoList()const
+{
+	return clientInfoList_;
+}
+
+bool DescribeGatewayNFSClientsResult::getVersion3Enabled()const
+{
+	return version3Enabled_;
+}
+
+std::string DescribeGatewayNFSClientsResult::getCode()const
+{
+	return code_;
+}
+
+bool DescribeGatewayNFSClientsResult::getSuccess()const
+{
+	return success_;
+}
+

sgw/src/model/DescribeGatewayResult.cc

@@ -118,6 +118,8 @@ void DescribeGatewayResult::parse(const std::string &payload)
 		dataLoadInterval_ = std::stoi(value["DataLoadInterval"].asString());
 	if(!value["LastErrorKey"].isNull())
 		lastErrorKey_ = value["LastErrorKey"].asString();
+	if(!value["InnerIpv6Ip"].isNull())
+		innerIpv6Ip_ = value["InnerIpv6Ip"].asString();
 
 }
 
@@ -306,6 +308,11 @@ std::string DescribeGatewayResult::getModel()const
 	return model_;
 }
 
+std::string DescribeGatewayResult::getInnerIpv6Ip()const
+{
+	return innerIpv6Ip_;
+}
+
 std::string DescribeGatewayResult::getLastErrorKey()const
 {
 	return lastErrorKey_;

sgw/src/model/DescribeGatewaysResult.cc

@@ -113,6 +113,8 @@ void DescribeGatewaysResult::parse(const std::string &payload)
 			gatewaysObject.dataLoadInterval = std::stoi(valueGatewaysGateway["DataLoadInterval"].asString());
 		if(!valueGatewaysGateway["LastErrorKey"].isNull())
 			gatewaysObject.lastErrorKey = valueGatewaysGateway["LastErrorKey"].asString();
+		if(!valueGatewaysGateway["InnerIpv6Ip"].isNull())
+			gatewaysObject.innerIpv6Ip = valueGatewaysGateway["InnerIpv6Ip"].asString();
 		auto allElasticNodes = value["ElasticNodes"]["ElasticNode"];
 		for (auto value : allElasticNodes)
 			gatewaysObject.elasticNodes.push_back(value.asString());

sgw/src/model/DescribeGatewaysTagsResult.cc

@@ -45,14 +45,14 @@ void DescribeGatewaysTagsResult::parse(const std::string &payload)
 		GatewayTag gatewayTagsObject;
 		if(!valueGatewayTagsGatewayTag["GatewayId"].isNull())
 			gatewayTagsObject.gatewayId = valueGatewayTagsGatewayTag["GatewayId"].asString();
-		auto allTagsNode = allGatewayTagsNode["Tags"]["Tag"];
-		for (auto allGatewayTagsNodeTagsTag : allTagsNode)
+		auto allTagsNode = valueGatewayTagsGatewayTag["Tags"]["Tag"];
+		for (auto valueGatewayTagsGatewayTagTagsTag : allTagsNode)
 		{
 			GatewayTag::Tag tagsObject;
-			if(!allGatewayTagsNodeTagsTag["TagKey"].isNull())
-				tagsObject.tagKey = allGatewayTagsNodeTagsTag["TagKey"].asString();
-			if(!allGatewayTagsNodeTagsTag["TagValue"].isNull())
-				tagsObject.tagValue = allGatewayTagsNodeTagsTag["TagValue"].asString();
+			if(!valueGatewayTagsGatewayTagTagsTag["TagKey"].isNull())
+				tagsObject.tagKey = valueGatewayTagsGatewayTagTagsTag["TagKey"].asString();
+			if(!valueGatewayTagsGatewayTagTagsTag["TagValue"].isNull())
+				tagsObject.tagValue = valueGatewayTagsGatewayTagTagsTag["TagValue"].asString();
 			gatewayTagsObject.tags.push_back(tagsObject);
 		}
 		gatewayTags_.push_back(gatewayTagsObject);

sgw/src/model/DescribeOssBucketInfoResult.cc

@@ -57,6 +57,8 @@ void DescribeOssBucketInfoResult::parse(const std::string &payload)
 		isFresh_ = value["IsFresh"].asString() == "true";
 	if(!value["StorageSize"].isNull())
 		storageSize_ = std::stol(value["StorageSize"].asString());
+	if(!value["IsVersioning"].isNull())
+		isVersioning_ = value["IsVersioning"].asString() == "true";
 
 }
 
@@ -95,6 +97,11 @@ int DescribeOssBucketInfoResult::getPollingInterval()const
 	return pollingInterval_;
 }
 
+bool DescribeOssBucketInfoResult::getIsVersioning()const
+{
+	return isVersioning_;
+}
+
 std::string DescribeOssBucketInfoResult::getCode()const
 {
 	return code_;

sgw/src/model/DisableGatewayNFSVersionRequest.cc

@@ -0,0 +1,73 @@
+/*
+ * 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/sgw/model/DisableGatewayNFSVersionRequest.h>
+
+using AlibabaCloud::Sgw::Model::DisableGatewayNFSVersionRequest;
+
+DisableGatewayNFSVersionRequest::DisableGatewayNFSVersionRequest() :
+	RpcServiceRequest("sgw", "2018-05-11", "DisableGatewayNFSVersion")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DisableGatewayNFSVersionRequest::~DisableGatewayNFSVersionRequest()
+{}
+
+std::string DisableGatewayNFSVersionRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DisableGatewayNFSVersionRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DisableGatewayNFSVersionRequest::getNFSVersion()const
+{
+	return nFSVersion_;
+}
+
+void DisableGatewayNFSVersionRequest::setNFSVersion(const std::string& nFSVersion)
+{
+	nFSVersion_ = nFSVersion;
+	setParameter("NFSVersion", nFSVersion);
+}
+
+std::string DisableGatewayNFSVersionRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DisableGatewayNFSVersionRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DisableGatewayNFSVersionRequest::getGatewayId()const
+{
+	return gatewayId_;
+}
+
+void DisableGatewayNFSVersionRequest::setGatewayId(const std::string& gatewayId)
+{
+	gatewayId_ = gatewayId;
+	setParameter("GatewayId", gatewayId);
+}
+

sgw/src/model/DisableGatewayNFSVersionResult.cc

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

sgw/src/model/EnableGatewayIpv6Request.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/sgw/model/EnableGatewayIpv6Request.h>
+
+using AlibabaCloud::Sgw::Model::EnableGatewayIpv6Request;
+
+EnableGatewayIpv6Request::EnableGatewayIpv6Request() :
+	RpcServiceRequest("sgw", "2018-05-11", "EnableGatewayIpv6")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+EnableGatewayIpv6Request::~EnableGatewayIpv6Request()
+{}
+
+std::string EnableGatewayIpv6Request::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void EnableGatewayIpv6Request::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string EnableGatewayIpv6Request::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void EnableGatewayIpv6Request::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string EnableGatewayIpv6Request::getGatewayId()const
+{
+	return gatewayId_;
+}
+
+void EnableGatewayIpv6Request::setGatewayId(const std::string& gatewayId)
+{
+	gatewayId_ = gatewayId;
+	setParameter("GatewayId", gatewayId);
+}
+

sgw/src/model/EnableGatewayIpv6Result.cc

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

sgw/src/model/ModifyGatewayFileShareWatermarkRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/sgw/model/ModifyGatewayFileShareWatermarkRequest.h>
+
+using AlibabaCloud::Sgw::Model::ModifyGatewayFileShareWatermarkRequest;
+
+ModifyGatewayFileShareWatermarkRequest::ModifyGatewayFileShareWatermarkRequest() :
+	RpcServiceRequest("sgw", "2018-05-11", "ModifyGatewayFileShareWatermark")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ModifyGatewayFileShareWatermarkRequest::~ModifyGatewayFileShareWatermarkRequest()
+{}
+
+int ModifyGatewayFileShareWatermarkRequest::getWatermark()const
+{
+	return watermark_;
+}
+
+void ModifyGatewayFileShareWatermarkRequest::setWatermark(int watermark)
+{
+	watermark_ = watermark;
+	setParameter("Watermark", std::to_string(watermark));
+}
+
+std::string ModifyGatewayFileShareWatermarkRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void ModifyGatewayFileShareWatermarkRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string ModifyGatewayFileShareWatermarkRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void ModifyGatewayFileShareWatermarkRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string ModifyGatewayFileShareWatermarkRequest::getIndexId()const
+{
+	return indexId_;
+}
+
+void ModifyGatewayFileShareWatermarkRequest::setIndexId(const std::string& indexId)
+{
+	indexId_ = indexId;
+	setParameter("IndexId", indexId);
+}
+
+std::string ModifyGatewayFileShareWatermarkRequest::getGatewayId()const
+{
+	return gatewayId_;
+}
+
+void ModifyGatewayFileShareWatermarkRequest::setGatewayId(const std::string& gatewayId)
+{
+	gatewayId_ = gatewayId;
+	setParameter("GatewayId", gatewayId);
+}
+

sgw/src/model/ModifyGatewayFileShareWatermarkResult.cc

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

sgw/src/model/OpenSgwServiceRequest.cc

@@ -0,0 +1,29 @@
+/*
+ * 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/sgw/model/OpenSgwServiceRequest.h>
+
+using AlibabaCloud::Sgw::Model::OpenSgwServiceRequest;
+
+OpenSgwServiceRequest::OpenSgwServiceRequest() :
+	RpcServiceRequest("sgw", "2018-05-11", "OpenSgwService")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+OpenSgwServiceRequest::~OpenSgwServiceRequest()
+{}
+

sgw/src/model/OpenSgwServiceResult.cc

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

sgw/src/model/TriggerGatewayRemoteSyncRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/sgw/model/TriggerGatewayRemoteSyncRequest.h>
+
+using AlibabaCloud::Sgw::Model::TriggerGatewayRemoteSyncRequest;
+
+TriggerGatewayRemoteSyncRequest::TriggerGatewayRemoteSyncRequest() :
+	RpcServiceRequest("sgw", "2018-05-11", "TriggerGatewayRemoteSync")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+TriggerGatewayRemoteSyncRequest::~TriggerGatewayRemoteSyncRequest()
+{}
+
+std::string TriggerGatewayRemoteSyncRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void TriggerGatewayRemoteSyncRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string TriggerGatewayRemoteSyncRequest::getPath()const
+{
+	return path_;
+}
+
+void TriggerGatewayRemoteSyncRequest::setPath(const std::string& path)
+{
+	path_ = path;
+	setParameter("Path", path);
+}
+
+std::string TriggerGatewayRemoteSyncRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void TriggerGatewayRemoteSyncRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string TriggerGatewayRemoteSyncRequest::getIndexId()const
+{
+	return indexId_;
+}
+
+void TriggerGatewayRemoteSyncRequest::setIndexId(const std::string& indexId)
+{
+	indexId_ = indexId;
+	setParameter("IndexId", indexId);
+}
+
+std::string TriggerGatewayRemoteSyncRequest::getGatewayId()const
+{
+	return gatewayId_;
+}
+
+void TriggerGatewayRemoteSyncRequest::setGatewayId(const std::string& gatewayId)
+{
+	gatewayId_ = gatewayId;
+	setParameter("GatewayId", gatewayId);
+}
+

sgw/src/model/TriggerGatewayRemoteSyncResult.cc

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

sgw/src/model/UpdateGatewayFileShareRequest.cc

@@ -93,6 +93,17 @@ void UpdateGatewayFileShareRequest::setReadWriteClientList(const std::string& re
 	setParameter("ReadWriteClientList", readWriteClientList);
 }
 
+bool UpdateGatewayFileShareRequest::getBypassCacheRead()const
+{
+	return bypassCacheRead_;
+}
+
+void UpdateGatewayFileShareRequest::setBypassCacheRead(bool bypassCacheRead)
+{
+	bypassCacheRead_ = bypassCacheRead;
+	setParameter("BypassCacheRead", bypassCacheRead ? "true" : "false");
+}
+
 std::string UpdateGatewayFileShareRequest::getAccessKeyId()const
 {
 	return accessKeyId_;

sgw/src/model/UpdateGatewayFileShareResult.cc

@@ -39,14 +39,14 @@ void UpdateGatewayFileShareResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
-	if(!value["Code"].isNull())
-		code_ = value["Code"].asString();
-	if(!value["Message"].isNull())
-		message_ = value["Message"].asString();
 	if(!value["TaskId"].isNull())
 		taskId_ = value["TaskId"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }