Change Configuration.

CHANGELOG

@@ -1,3 +1,33 @@
+2020-10-23 Version: patch
+- Change Configuration.
+
+2020-10-23 Version: patch
+- Update DetectLungNodule.
+
+2020-10-23 Version: patch
+- Support feedback.
+
+2020-10-22 Version: patch
+- Add Pipeline Member api.
+
+2020-10-22 Version: patch
+- Update data API.
+
+2020-10-22 Version: patch
+- Update cert API.
+
+2020-10-22 Version: patch
+- Update data API.
+
+2020-10-21 Version: patch
+- DescribeAvailableResource support AcceptLanguage.
+
+2020-10-21 Version: patch
+- Change Documentation configuration.
+
+2020-10-21 Version: patch
+- Cloud Storage Gateway openapi sdk is released.
+
 2020-10-21 Version: patch
 - Release latest features.
 

dcdn/CMakeLists.txt

@@ -113,6 +113,8 @@ set(dcdn_public_header_model
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainRealTimeSrcHttpCodeDataResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainRealTimeSrcTrafficDataRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainRealTimeSrcTrafficDataResult.h
+	include/alibabacloud/dcdn/model/DescribeDcdnDomainRealTimeTrafficDataRequest.h
+	include/alibabacloud/dcdn/model/DescribeDcdnDomainRealTimeTrafficDataResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainRegionDataRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainRegionDataResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainStagingConfigRequest.h
@@ -155,6 +157,8 @@ set(dcdn_public_header_model
 	include/alibabacloud/dcdn/model/DescribeDcdnTagResourcesResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnTopDomainsByFlowRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnTopDomainsByFlowResult.h
+	include/alibabacloud/dcdn/model/DescribeDcdnUserBillHistoryRequest.h
+	include/alibabacloud/dcdn/model/DescribeDcdnUserBillHistoryResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnUserBillTypeRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnUserBillTypeResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnUserDomainsRequest.h
@@ -302,6 +306,8 @@ set(dcdn_src
 	src/model/DescribeDcdnDomainRealTimeSrcHttpCodeDataResult.cc
 	src/model/DescribeDcdnDomainRealTimeSrcTrafficDataRequest.cc
 	src/model/DescribeDcdnDomainRealTimeSrcTrafficDataResult.cc
+	src/model/DescribeDcdnDomainRealTimeTrafficDataRequest.cc
+	src/model/DescribeDcdnDomainRealTimeTrafficDataResult.cc
 	src/model/DescribeDcdnDomainRegionDataRequest.cc
 	src/model/DescribeDcdnDomainRegionDataResult.cc
 	src/model/DescribeDcdnDomainStagingConfigRequest.cc
@@ -344,6 +350,8 @@ set(dcdn_src
 	src/model/DescribeDcdnTagResourcesResult.cc
 	src/model/DescribeDcdnTopDomainsByFlowRequest.cc
 	src/model/DescribeDcdnTopDomainsByFlowResult.cc
+	src/model/DescribeDcdnUserBillHistoryRequest.cc
+	src/model/DescribeDcdnUserBillHistoryResult.cc
 	src/model/DescribeDcdnUserBillTypeRequest.cc
 	src/model/DescribeDcdnUserBillTypeResult.cc
 	src/model/DescribeDcdnUserDomainsRequest.cc

dcdn/include/alibabacloud/dcdn/DcdnClient.h

@@ -114,6 +114,8 @@
 #include "model/DescribeDcdnDomainRealTimeSrcHttpCodeDataResult.h"
 #include "model/DescribeDcdnDomainRealTimeSrcTrafficDataRequest.h"
 #include "model/DescribeDcdnDomainRealTimeSrcTrafficDataResult.h"
+#include "model/DescribeDcdnDomainRealTimeTrafficDataRequest.h"
+#include "model/DescribeDcdnDomainRealTimeTrafficDataResult.h"
 #include "model/DescribeDcdnDomainRegionDataRequest.h"
 #include "model/DescribeDcdnDomainRegionDataResult.h"
 #include "model/DescribeDcdnDomainStagingConfigRequest.h"
@@ -156,6 +158,8 @@
 #include "model/DescribeDcdnTagResourcesResult.h"
 #include "model/DescribeDcdnTopDomainsByFlowRequest.h"
 #include "model/DescribeDcdnTopDomainsByFlowResult.h"
+#include "model/DescribeDcdnUserBillHistoryRequest.h"
+#include "model/DescribeDcdnUserBillHistoryResult.h"
 #include "model/DescribeDcdnUserBillTypeRequest.h"
 #include "model/DescribeDcdnUserBillTypeResult.h"
 #include "model/DescribeDcdnUserDomainsRequest.h"
@@ -355,6 +359,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeDcdnDomainRealTimeSrcTrafficDataResult> DescribeDcdnDomainRealTimeSrcTrafficDataOutcome;
 			typedef std::future<DescribeDcdnDomainRealTimeSrcTrafficDataOutcome> DescribeDcdnDomainRealTimeSrcTrafficDataOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnDomainRealTimeSrcTrafficDataRequest&, const DescribeDcdnDomainRealTimeSrcTrafficDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnDomainRealTimeSrcTrafficDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDcdnDomainRealTimeTrafficDataResult> DescribeDcdnDomainRealTimeTrafficDataOutcome;
+			typedef std::future<DescribeDcdnDomainRealTimeTrafficDataOutcome> DescribeDcdnDomainRealTimeTrafficDataOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnDomainRealTimeTrafficDataRequest&, const DescribeDcdnDomainRealTimeTrafficDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnDomainRealTimeTrafficDataAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDcdnDomainRegionDataResult> DescribeDcdnDomainRegionDataOutcome;
 			typedef std::future<DescribeDcdnDomainRegionDataOutcome> DescribeDcdnDomainRegionDataOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnDomainRegionDataRequest&, const DescribeDcdnDomainRegionDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnDomainRegionDataAsyncHandler;
@@ -418,6 +425,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeDcdnTopDomainsByFlowResult> DescribeDcdnTopDomainsByFlowOutcome;
 			typedef std::future<DescribeDcdnTopDomainsByFlowOutcome> DescribeDcdnTopDomainsByFlowOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnTopDomainsByFlowRequest&, const DescribeDcdnTopDomainsByFlowOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnTopDomainsByFlowAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDcdnUserBillHistoryResult> DescribeDcdnUserBillHistoryOutcome;
+			typedef std::future<DescribeDcdnUserBillHistoryOutcome> DescribeDcdnUserBillHistoryOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnUserBillHistoryRequest&, const DescribeDcdnUserBillHistoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnUserBillHistoryAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDcdnUserBillTypeResult> DescribeDcdnUserBillTypeOutcome;
 			typedef std::future<DescribeDcdnUserBillTypeOutcome> DescribeDcdnUserBillTypeOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnUserBillTypeRequest&, const DescribeDcdnUserBillTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnUserBillTypeAsyncHandler;
@@ -639,6 +649,9 @@ namespace AlibabaCloud
 			DescribeDcdnDomainRealTimeSrcTrafficDataOutcome describeDcdnDomainRealTimeSrcTrafficData(const Model::DescribeDcdnDomainRealTimeSrcTrafficDataRequest &request)const;
 			void describeDcdnDomainRealTimeSrcTrafficDataAsync(const Model::DescribeDcdnDomainRealTimeSrcTrafficDataRequest& request, const DescribeDcdnDomainRealTimeSrcTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDcdnDomainRealTimeSrcTrafficDataOutcomeCallable describeDcdnDomainRealTimeSrcTrafficDataCallable(const Model::DescribeDcdnDomainRealTimeSrcTrafficDataRequest& request) const;
+			DescribeDcdnDomainRealTimeTrafficDataOutcome describeDcdnDomainRealTimeTrafficData(const Model::DescribeDcdnDomainRealTimeTrafficDataRequest &request)const;
+			void describeDcdnDomainRealTimeTrafficDataAsync(const Model::DescribeDcdnDomainRealTimeTrafficDataRequest& request, const DescribeDcdnDomainRealTimeTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDcdnDomainRealTimeTrafficDataOutcomeCallable describeDcdnDomainRealTimeTrafficDataCallable(const Model::DescribeDcdnDomainRealTimeTrafficDataRequest& request) const;
 			DescribeDcdnDomainRegionDataOutcome describeDcdnDomainRegionData(const Model::DescribeDcdnDomainRegionDataRequest &request)const;
 			void describeDcdnDomainRegionDataAsync(const Model::DescribeDcdnDomainRegionDataRequest& request, const DescribeDcdnDomainRegionDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDcdnDomainRegionDataOutcomeCallable describeDcdnDomainRegionDataCallable(const Model::DescribeDcdnDomainRegionDataRequest& request) const;
@@ -702,6 +715,9 @@ namespace AlibabaCloud
 			DescribeDcdnTopDomainsByFlowOutcome describeDcdnTopDomainsByFlow(const Model::DescribeDcdnTopDomainsByFlowRequest &request)const;
 			void describeDcdnTopDomainsByFlowAsync(const Model::DescribeDcdnTopDomainsByFlowRequest& request, const DescribeDcdnTopDomainsByFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDcdnTopDomainsByFlowOutcomeCallable describeDcdnTopDomainsByFlowCallable(const Model::DescribeDcdnTopDomainsByFlowRequest& request) const;
+			DescribeDcdnUserBillHistoryOutcome describeDcdnUserBillHistory(const Model::DescribeDcdnUserBillHistoryRequest &request)const;
+			void describeDcdnUserBillHistoryAsync(const Model::DescribeDcdnUserBillHistoryRequest& request, const DescribeDcdnUserBillHistoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDcdnUserBillHistoryOutcomeCallable describeDcdnUserBillHistoryCallable(const Model::DescribeDcdnUserBillHistoryRequest& request) const;
 			DescribeDcdnUserBillTypeOutcome describeDcdnUserBillType(const Model::DescribeDcdnUserBillTypeRequest &request)const;
 			void describeDcdnUserBillTypeAsync(const Model::DescribeDcdnUserBillTypeRequest& request, const DescribeDcdnUserBillTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDcdnUserBillTypeOutcomeCallable describeDcdnUserBillTypeCallable(const Model::DescribeDcdnUserBillTypeRequest& request) const;

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainRealTimeTrafficDataRequest.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_DCDN_MODEL_DESCRIBEDCDNDOMAINREALTIMETRAFFICDATAREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINREALTIMETRAFFICDATAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dcdn/DcdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dcdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnDomainRealTimeTrafficDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDcdnDomainRealTimeTrafficDataRequest();
+				~DescribeDcdnDomainRealTimeTrafficDataRequest();
+
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				std::string startTime_;
+				std::string domainName_;
+				std::string endTime_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINREALTIMETRAFFICDATAREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainRealTimeTrafficDataResult.h

@@ -0,0 +1,64 @@
+/*
+ * 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_DCDN_MODEL_DESCRIBEDCDNDOMAINREALTIMETRAFFICDATARESULT_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINREALTIMETRAFFICDATARESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dcdn/DcdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dcdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnDomainRealTimeTrafficDataResult : public ServiceResult
+			{
+			public:
+				struct DataModule
+				{
+					std::string value;
+					std::string timeStamp;
+				};
+
+
+				DescribeDcdnDomainRealTimeTrafficDataResult();
+				explicit DescribeDcdnDomainRealTimeTrafficDataResult(const std::string &payload);
+				~DescribeDcdnDomainRealTimeTrafficDataResult();
+				std::string getEndTime()const;
+				std::vector<DataModule> getRealTimeTrafficDataPerInterval()const;
+				std::string getDomainName()const;
+				std::string getStartTime()const;
+				std::string getDataInterval()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string endTime_;
+				std::vector<DataModule> realTimeTrafficDataPerInterval_;
+				std::string domainName_;
+				std::string startTime_;
+				std::string dataInterval_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINREALTIMETRAFFICDATARESULT_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnUserBillHistoryRequest.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_DCDN_MODEL_DESCRIBEDCDNUSERBILLHISTORYREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNUSERBILLHISTORYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dcdn/DcdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dcdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnUserBillHistoryRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDcdnUserBillHistoryRequest();
+				~DescribeDcdnUserBillHistoryRequest();
+
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				std::string startTime_;
+				std::string endTime_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNUSERBILLHISTORYREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnUserBillHistoryResult.h

@@ -0,0 +1,66 @@
+/*
+ * 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_DCDN_MODEL_DESCRIBEDCDNUSERBILLHISTORYRESULT_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNUSERBILLHISTORYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dcdn/DcdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dcdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnUserBillHistoryResult : public ServiceResult
+			{
+			public:
+				struct BillHistoryDataItem
+				{
+					struct BillingDataItem
+					{
+						std::string chargeType;
+						float bandwidth;
+						std::string cdnRegion;
+						float count;
+						float flow;
+					};
+					std::string billType;
+					std::string billTime;
+					std::vector<BillHistoryDataItem::BillingDataItem> billingData;
+					std::string dimension;
+				};
+
+
+				DescribeDcdnUserBillHistoryResult();
+				explicit DescribeDcdnUserBillHistoryResult(const std::string &payload);
+				~DescribeDcdnUserBillHistoryResult();
+				std::vector<BillHistoryDataItem> getBillHistoryData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<BillHistoryDataItem> billHistoryData_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNUSERBILLHISTORYRESULT_H_

dcdn/src/DcdnClient.cc

@@ -1707,6 +1707,42 @@ DcdnClient::DescribeDcdnDomainRealTimeSrcTrafficDataOutcomeCallable DcdnClient::
 	return task->get_future();
 }
 
+DcdnClient::DescribeDcdnDomainRealTimeTrafficDataOutcome DcdnClient::describeDcdnDomainRealTimeTrafficData(const DescribeDcdnDomainRealTimeTrafficDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDcdnDomainRealTimeTrafficDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDcdnDomainRealTimeTrafficDataOutcome(DescribeDcdnDomainRealTimeTrafficDataResult(outcome.result()));
+	else
+		return DescribeDcdnDomainRealTimeTrafficDataOutcome(outcome.error());
+}
+
+void DcdnClient::describeDcdnDomainRealTimeTrafficDataAsync(const DescribeDcdnDomainRealTimeTrafficDataRequest& request, const DescribeDcdnDomainRealTimeTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDcdnDomainRealTimeTrafficData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::DescribeDcdnDomainRealTimeTrafficDataOutcomeCallable DcdnClient::describeDcdnDomainRealTimeTrafficDataCallable(const DescribeDcdnDomainRealTimeTrafficDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDcdnDomainRealTimeTrafficDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDcdnDomainRealTimeTrafficData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DcdnClient::DescribeDcdnDomainRegionDataOutcome DcdnClient::describeDcdnDomainRegionData(const DescribeDcdnDomainRegionDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2463,6 +2499,42 @@ DcdnClient::DescribeDcdnTopDomainsByFlowOutcomeCallable DcdnClient::describeDcdn
 	return task->get_future();
 }
 
+DcdnClient::DescribeDcdnUserBillHistoryOutcome DcdnClient::describeDcdnUserBillHistory(const DescribeDcdnUserBillHistoryRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDcdnUserBillHistoryOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDcdnUserBillHistoryOutcome(DescribeDcdnUserBillHistoryResult(outcome.result()));
+	else
+		return DescribeDcdnUserBillHistoryOutcome(outcome.error());
+}
+
+void DcdnClient::describeDcdnUserBillHistoryAsync(const DescribeDcdnUserBillHistoryRequest& request, const DescribeDcdnUserBillHistoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDcdnUserBillHistory(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::DescribeDcdnUserBillHistoryOutcomeCallable DcdnClient::describeDcdnUserBillHistoryCallable(const DescribeDcdnUserBillHistoryRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDcdnUserBillHistoryOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDcdnUserBillHistory(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DcdnClient::DescribeDcdnUserBillTypeOutcome DcdnClient::describeDcdnUserBillType(const DescribeDcdnUserBillTypeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

dcdn/src/model/DescribeDcdnDomainRealTimeTrafficDataRequest.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/dcdn/model/DescribeDcdnDomainRealTimeTrafficDataRequest.h>
+
+using AlibabaCloud::Dcdn::Model::DescribeDcdnDomainRealTimeTrafficDataRequest;
+
+DescribeDcdnDomainRealTimeTrafficDataRequest::DescribeDcdnDomainRealTimeTrafficDataRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnDomainRealTimeTrafficData")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDcdnDomainRealTimeTrafficDataRequest::~DescribeDcdnDomainRealTimeTrafficDataRequest()
+{}
+
+std::string DescribeDcdnDomainRealTimeTrafficDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeDcdnDomainRealTimeTrafficDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeDcdnDomainRealTimeTrafficDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeDcdnDomainRealTimeTrafficDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeDcdnDomainRealTimeTrafficDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeDcdnDomainRealTimeTrafficDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+long DescribeDcdnDomainRealTimeTrafficDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDcdnDomainRealTimeTrafficDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

dcdn/src/model/DescribeDcdnDomainRealTimeTrafficDataResult.cc

@@ -0,0 +1,87 @@
+/*
+ * 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/dcdn/model/DescribeDcdnDomainRealTimeTrafficDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+DescribeDcdnDomainRealTimeTrafficDataResult::DescribeDcdnDomainRealTimeTrafficDataResult() :
+	ServiceResult()
+{}
+
+DescribeDcdnDomainRealTimeTrafficDataResult::DescribeDcdnDomainRealTimeTrafficDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDcdnDomainRealTimeTrafficDataResult::~DescribeDcdnDomainRealTimeTrafficDataResult()
+{}
+
+void DescribeDcdnDomainRealTimeTrafficDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allRealTimeTrafficDataPerIntervalNode = value["RealTimeTrafficDataPerInterval"]["DataModule"];
+	for (auto valueRealTimeTrafficDataPerIntervalDataModule : allRealTimeTrafficDataPerIntervalNode)
+	{
+		DataModule realTimeTrafficDataPerIntervalObject;
+		if(!valueRealTimeTrafficDataPerIntervalDataModule["TimeStamp"].isNull())
+			realTimeTrafficDataPerIntervalObject.timeStamp = valueRealTimeTrafficDataPerIntervalDataModule["TimeStamp"].asString();
+		if(!valueRealTimeTrafficDataPerIntervalDataModule["Value"].isNull())
+			realTimeTrafficDataPerIntervalObject.value = valueRealTimeTrafficDataPerIntervalDataModule["Value"].asString();
+		realTimeTrafficDataPerInterval_.push_back(realTimeTrafficDataPerIntervalObject);
+	}
+	if(!value["DomainName"].isNull())
+		domainName_ = value["DomainName"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+	if(!value["DataInterval"].isNull())
+		dataInterval_ = value["DataInterval"].asString();
+
+}
+
+std::string DescribeDcdnDomainRealTimeTrafficDataResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::vector<DescribeDcdnDomainRealTimeTrafficDataResult::DataModule> DescribeDcdnDomainRealTimeTrafficDataResult::getRealTimeTrafficDataPerInterval()const
+{
+	return realTimeTrafficDataPerInterval_;
+}
+
+std::string DescribeDcdnDomainRealTimeTrafficDataResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::string DescribeDcdnDomainRealTimeTrafficDataResult::getStartTime()const
+{
+	return startTime_;
+}
+
+std::string DescribeDcdnDomainRealTimeTrafficDataResult::getDataInterval()const
+{
+	return dataInterval_;
+}
+

dcdn/src/model/DescribeDcdnUserBillHistoryRequest.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/dcdn/model/DescribeDcdnUserBillHistoryRequest.h>
+
+using AlibabaCloud::Dcdn::Model::DescribeDcdnUserBillHistoryRequest;
+
+DescribeDcdnUserBillHistoryRequest::DescribeDcdnUserBillHistoryRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnUserBillHistory")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDcdnUserBillHistoryRequest::~DescribeDcdnUserBillHistoryRequest()
+{}
+
+std::string DescribeDcdnUserBillHistoryRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeDcdnUserBillHistoryRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeDcdnUserBillHistoryRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeDcdnUserBillHistoryRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+long DescribeDcdnUserBillHistoryRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDcdnUserBillHistoryRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

dcdn/src/model/DescribeDcdnUserBillHistoryResult.cc

@@ -0,0 +1,77 @@
+/*
+ * 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/dcdn/model/DescribeDcdnUserBillHistoryResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+DescribeDcdnUserBillHistoryResult::DescribeDcdnUserBillHistoryResult() :
+	ServiceResult()
+{}
+
+DescribeDcdnUserBillHistoryResult::DescribeDcdnUserBillHistoryResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDcdnUserBillHistoryResult::~DescribeDcdnUserBillHistoryResult()
+{}
+
+void DescribeDcdnUserBillHistoryResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allBillHistoryDataNode = value["BillHistoryData"]["BillHistoryDataItem"];
+	for (auto valueBillHistoryDataBillHistoryDataItem : allBillHistoryDataNode)
+	{
+		BillHistoryDataItem billHistoryDataObject;
+		if(!valueBillHistoryDataBillHistoryDataItem["Dimension"].isNull())
+			billHistoryDataObject.dimension = valueBillHistoryDataBillHistoryDataItem["Dimension"].asString();
+		if(!valueBillHistoryDataBillHistoryDataItem["BillType"].isNull())
+			billHistoryDataObject.billType = valueBillHistoryDataBillHistoryDataItem["BillType"].asString();
+		if(!valueBillHistoryDataBillHistoryDataItem["BillTime"].isNull())
+			billHistoryDataObject.billTime = valueBillHistoryDataBillHistoryDataItem["BillTime"].asString();
+		auto allBillingDataNode = allBillHistoryDataNode["BillingData"]["BillingDataItem"];
+		for (auto allBillHistoryDataNodeBillingDataBillingDataItem : allBillingDataNode)
+		{
+			BillHistoryDataItem::BillingDataItem billingDataObject;
+			if(!allBillHistoryDataNodeBillingDataBillingDataItem["ChargeType"].isNull())
+				billingDataObject.chargeType = allBillHistoryDataNodeBillingDataBillingDataItem["ChargeType"].asString();
+			if(!allBillHistoryDataNodeBillingDataBillingDataItem["CdnRegion"].isNull())
+				billingDataObject.cdnRegion = allBillHistoryDataNodeBillingDataBillingDataItem["CdnRegion"].asString();
+			if(!allBillHistoryDataNodeBillingDataBillingDataItem["Bandwidth"].isNull())
+				billingDataObject.bandwidth = std::stof(allBillHistoryDataNodeBillingDataBillingDataItem["Bandwidth"].asString());
+			if(!allBillHistoryDataNodeBillingDataBillingDataItem["Flow"].isNull())
+				billingDataObject.flow = std::stof(allBillHistoryDataNodeBillingDataBillingDataItem["Flow"].asString());
+			if(!allBillHistoryDataNodeBillingDataBillingDataItem["Count"].isNull())
+				billingDataObject.count = std::stof(allBillHistoryDataNodeBillingDataBillingDataItem["Count"].asString());
+			billHistoryDataObject.billingData.push_back(billingDataObject);
+		}
+		billHistoryData_.push_back(billHistoryDataObject);
+	}
+
+}
+
+std::vector<DescribeDcdnUserBillHistoryResult::BillHistoryDataItem> DescribeDcdnUserBillHistoryResult::getBillHistoryData()const
+{
+	return billHistoryData_;
+}
+

devops-rdc/CMakeLists.txt

@@ -51,6 +51,8 @@ set(devops-rdc_public_header_model
 	include/alibabacloud/devops-rdc/model/DeleteDevopsProjectSprintResult.h
 	include/alibabacloud/devops-rdc/model/DeleteDevopsProjectTaskRequest.h
 	include/alibabacloud/devops-rdc/model/DeleteDevopsProjectTaskResult.h
+	include/alibabacloud/devops-rdc/model/DeletePipelineMemberRequest.h
+	include/alibabacloud/devops-rdc/model/DeletePipelineMemberResult.h
 	include/alibabacloud/devops-rdc/model/ExecutePipelineRequest.h
 	include/alibabacloud/devops-rdc/model/ExecutePipelineResult.h
 	include/alibabacloud/devops-rdc/model/GetDevopsOrganizationMembersRequest.h
@@ -79,6 +81,8 @@ set(devops-rdc_public_header_model
 	include/alibabacloud/devops-rdc/model/GetUserByAliyunUidResult.h
 	include/alibabacloud/devops-rdc/model/InsertDevopsUserRequest.h
 	include/alibabacloud/devops-rdc/model/InsertDevopsUserResult.h
+	include/alibabacloud/devops-rdc/model/InsertPipelineMemberRequest.h
+	include/alibabacloud/devops-rdc/model/InsertPipelineMemberResult.h
 	include/alibabacloud/devops-rdc/model/InsertProjectMembersRequest.h
 	include/alibabacloud/devops-rdc/model/InsertProjectMembersResult.h
 	include/alibabacloud/devops-rdc/model/ListCredentialsRequest.h
@@ -99,12 +103,16 @@ set(devops-rdc_public_header_model
 	include/alibabacloud/devops-rdc/model/ListServiceConnectionsResult.h
 	include/alibabacloud/devops-rdc/model/ListUserOrganizationRequest.h
 	include/alibabacloud/devops-rdc/model/ListUserOrganizationResult.h
+	include/alibabacloud/devops-rdc/model/TransferPipelineOwnerRequest.h
+	include/alibabacloud/devops-rdc/model/TransferPipelineOwnerResult.h
 	include/alibabacloud/devops-rdc/model/UpdateDevopsProjectRequest.h
 	include/alibabacloud/devops-rdc/model/UpdateDevopsProjectResult.h
 	include/alibabacloud/devops-rdc/model/UpdateDevopsProjectSprintRequest.h
 	include/alibabacloud/devops-rdc/model/UpdateDevopsProjectSprintResult.h
 	include/alibabacloud/devops-rdc/model/UpdateDevopsProjectTaskRequest.h
-	include/alibabacloud/devops-rdc/model/UpdateDevopsProjectTaskResult.h )
+	include/alibabacloud/devops-rdc/model/UpdateDevopsProjectTaskResult.h
+	include/alibabacloud/devops-rdc/model/UpdatePipelineMemberRequest.h
+	include/alibabacloud/devops-rdc/model/UpdatePipelineMemberResult.h )
 
 set(devops-rdc_src 
 	src/Devops-rdcClient.cc
@@ -138,6 +146,8 @@ set(devops-rdc_src
 	src/model/DeleteDevopsProjectSprintResult.cc
 	src/model/DeleteDevopsProjectTaskRequest.cc
 	src/model/DeleteDevopsProjectTaskResult.cc
+	src/model/DeletePipelineMemberRequest.cc
+	src/model/DeletePipelineMemberResult.cc
 	src/model/ExecutePipelineRequest.cc
 	src/model/ExecutePipelineResult.cc
 	src/model/GetDevopsOrganizationMembersRequest.cc
@@ -166,6 +176,8 @@ set(devops-rdc_src
 	src/model/GetUserByAliyunUidResult.cc
 	src/model/InsertDevopsUserRequest.cc
 	src/model/InsertDevopsUserResult.cc
+	src/model/InsertPipelineMemberRequest.cc
+	src/model/InsertPipelineMemberResult.cc
 	src/model/InsertProjectMembersRequest.cc
 	src/model/InsertProjectMembersResult.cc
 	src/model/ListCredentialsRequest.cc
@@ -186,12 +198,16 @@ set(devops-rdc_src
 	src/model/ListServiceConnectionsResult.cc
 	src/model/ListUserOrganizationRequest.cc
 	src/model/ListUserOrganizationResult.cc
+	src/model/TransferPipelineOwnerRequest.cc
+	src/model/TransferPipelineOwnerResult.cc
 	src/model/UpdateDevopsProjectRequest.cc
 	src/model/UpdateDevopsProjectResult.cc
 	src/model/UpdateDevopsProjectSprintRequest.cc
 	src/model/UpdateDevopsProjectSprintResult.cc
 	src/model/UpdateDevopsProjectTaskRequest.cc
-	src/model/UpdateDevopsProjectTaskResult.cc )
+	src/model/UpdateDevopsProjectTaskResult.cc
+	src/model/UpdatePipelineMemberRequest.cc
+	src/model/UpdatePipelineMemberResult.cc )
 
 add_library(devops-rdc ${LIB_TYPE}
 	${devops-rdc_public_header}

devops-rdc/include/alibabacloud/devops-rdc/Devops_rdcClient.h

@@ -52,6 +52,8 @@
 #include "model/DeleteDevopsProjectSprintResult.h"
 #include "model/DeleteDevopsProjectTaskRequest.h"
 #include "model/DeleteDevopsProjectTaskResult.h"
+#include "model/DeletePipelineMemberRequest.h"
+#include "model/DeletePipelineMemberResult.h"
 #include "model/ExecutePipelineRequest.h"
 #include "model/ExecutePipelineResult.h"
 #include "model/GetDevopsOrganizationMembersRequest.h"
@@ -80,6 +82,8 @@
 #include "model/GetUserByAliyunUidResult.h"
 #include "model/InsertDevopsUserRequest.h"
 #include "model/InsertDevopsUserResult.h"
+#include "model/InsertPipelineMemberRequest.h"
+#include "model/InsertPipelineMemberResult.h"
 #include "model/InsertProjectMembersRequest.h"
 #include "model/InsertProjectMembersResult.h"
 #include "model/ListCredentialsRequest.h"
@@ -100,12 +104,16 @@
 #include "model/ListServiceConnectionsResult.h"
 #include "model/ListUserOrganizationRequest.h"
 #include "model/ListUserOrganizationResult.h"
+#include "model/TransferPipelineOwnerRequest.h"
+#include "model/TransferPipelineOwnerResult.h"
 #include "model/UpdateDevopsProjectRequest.h"
 #include "model/UpdateDevopsProjectResult.h"
 #include "model/UpdateDevopsProjectSprintRequest.h"
 #include "model/UpdateDevopsProjectSprintResult.h"
 #include "model/UpdateDevopsProjectTaskRequest.h"
 #include "model/UpdateDevopsProjectTaskResult.h"
+#include "model/UpdatePipelineMemberRequest.h"
+#include "model/UpdatePipelineMemberResult.h"
 
 
 namespace AlibabaCloud
@@ -160,6 +168,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteDevopsProjectTaskResult> DeleteDevopsProjectTaskOutcome;
 			typedef std::future<DeleteDevopsProjectTaskOutcome> DeleteDevopsProjectTaskOutcomeCallable;
 			typedef std::function<void(const Devops_rdcClient*, const Model::DeleteDevopsProjectTaskRequest&, const DeleteDevopsProjectTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDevopsProjectTaskAsyncHandler;
+			typedef Outcome<Error, Model::DeletePipelineMemberResult> DeletePipelineMemberOutcome;
+			typedef std::future<DeletePipelineMemberOutcome> DeletePipelineMemberOutcomeCallable;
+			typedef std::function<void(const Devops_rdcClient*, const Model::DeletePipelineMemberRequest&, const DeletePipelineMemberOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeletePipelineMemberAsyncHandler;
 			typedef Outcome<Error, Model::ExecutePipelineResult> ExecutePipelineOutcome;
 			typedef std::future<ExecutePipelineOutcome> ExecutePipelineOutcomeCallable;
 			typedef std::function<void(const Devops_rdcClient*, const Model::ExecutePipelineRequest&, const ExecutePipelineOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExecutePipelineAsyncHandler;
@@ -202,6 +213,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::InsertDevopsUserResult> InsertDevopsUserOutcome;
 			typedef std::future<InsertDevopsUserOutcome> InsertDevopsUserOutcomeCallable;
 			typedef std::function<void(const Devops_rdcClient*, const Model::InsertDevopsUserRequest&, const InsertDevopsUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> InsertDevopsUserAsyncHandler;
+			typedef Outcome<Error, Model::InsertPipelineMemberResult> InsertPipelineMemberOutcome;
+			typedef std::future<InsertPipelineMemberOutcome> InsertPipelineMemberOutcomeCallable;
+			typedef std::function<void(const Devops_rdcClient*, const Model::InsertPipelineMemberRequest&, const InsertPipelineMemberOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> InsertPipelineMemberAsyncHandler;
 			typedef Outcome<Error, Model::InsertProjectMembersResult> InsertProjectMembersOutcome;
 			typedef std::future<InsertProjectMembersOutcome> InsertProjectMembersOutcomeCallable;
 			typedef std::function<void(const Devops_rdcClient*, const Model::InsertProjectMembersRequest&, const InsertProjectMembersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> InsertProjectMembersAsyncHandler;
@@ -232,6 +246,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListUserOrganizationResult> ListUserOrganizationOutcome;
 			typedef std::future<ListUserOrganizationOutcome> ListUserOrganizationOutcomeCallable;
 			typedef std::function<void(const Devops_rdcClient*, const Model::ListUserOrganizationRequest&, const ListUserOrganizationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListUserOrganizationAsyncHandler;
+			typedef Outcome<Error, Model::TransferPipelineOwnerResult> TransferPipelineOwnerOutcome;
+			typedef std::future<TransferPipelineOwnerOutcome> TransferPipelineOwnerOutcomeCallable;
+			typedef std::function<void(const Devops_rdcClient*, const Model::TransferPipelineOwnerRequest&, const TransferPipelineOwnerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TransferPipelineOwnerAsyncHandler;
 			typedef Outcome<Error, Model::UpdateDevopsProjectResult> UpdateDevopsProjectOutcome;
 			typedef std::future<UpdateDevopsProjectOutcome> UpdateDevopsProjectOutcomeCallable;
 			typedef std::function<void(const Devops_rdcClient*, const Model::UpdateDevopsProjectRequest&, const UpdateDevopsProjectOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateDevopsProjectAsyncHandler;
@@ -241,6 +258,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateDevopsProjectTaskResult> UpdateDevopsProjectTaskOutcome;
 			typedef std::future<UpdateDevopsProjectTaskOutcome> UpdateDevopsProjectTaskOutcomeCallable;
 			typedef std::function<void(const Devops_rdcClient*, const Model::UpdateDevopsProjectTaskRequest&, const UpdateDevopsProjectTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateDevopsProjectTaskAsyncHandler;
+			typedef Outcome<Error, Model::UpdatePipelineMemberResult> UpdatePipelineMemberOutcome;
+			typedef std::future<UpdatePipelineMemberOutcome> UpdatePipelineMemberOutcomeCallable;
+			typedef std::function<void(const Devops_rdcClient*, const Model::UpdatePipelineMemberRequest&, const UpdatePipelineMemberOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdatePipelineMemberAsyncHandler;
 
 			Devops_rdcClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			Devops_rdcClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
@@ -291,6 +311,9 @@ namespace AlibabaCloud
 			DeleteDevopsProjectTaskOutcome deleteDevopsProjectTask(const Model::DeleteDevopsProjectTaskRequest &request)const;
 			void deleteDevopsProjectTaskAsync(const Model::DeleteDevopsProjectTaskRequest& request, const DeleteDevopsProjectTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteDevopsProjectTaskOutcomeCallable deleteDevopsProjectTaskCallable(const Model::DeleteDevopsProjectTaskRequest& request) const;
+			DeletePipelineMemberOutcome deletePipelineMember(const Model::DeletePipelineMemberRequest &request)const;
+			void deletePipelineMemberAsync(const Model::DeletePipelineMemberRequest& request, const DeletePipelineMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeletePipelineMemberOutcomeCallable deletePipelineMemberCallable(const Model::DeletePipelineMemberRequest& request) const;
 			ExecutePipelineOutcome executePipeline(const Model::ExecutePipelineRequest &request)const;
 			void executePipelineAsync(const Model::ExecutePipelineRequest& request, const ExecutePipelineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ExecutePipelineOutcomeCallable executePipelineCallable(const Model::ExecutePipelineRequest& request) const;
@@ -333,6 +356,9 @@ namespace AlibabaCloud
 			InsertDevopsUserOutcome insertDevopsUser(const Model::InsertDevopsUserRequest &request)const;
 			void insertDevopsUserAsync(const Model::InsertDevopsUserRequest& request, const InsertDevopsUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			InsertDevopsUserOutcomeCallable insertDevopsUserCallable(const Model::InsertDevopsUserRequest& request) const;
+			InsertPipelineMemberOutcome insertPipelineMember(const Model::InsertPipelineMemberRequest &request)const;
+			void insertPipelineMemberAsync(const Model::InsertPipelineMemberRequest& request, const InsertPipelineMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			InsertPipelineMemberOutcomeCallable insertPipelineMemberCallable(const Model::InsertPipelineMemberRequest& request) const;
 			InsertProjectMembersOutcome insertProjectMembers(const Model::InsertProjectMembersRequest &request)const;
 			void insertProjectMembersAsync(const Model::InsertProjectMembersRequest& request, const InsertProjectMembersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			InsertProjectMembersOutcomeCallable insertProjectMembersCallable(const Model::InsertProjectMembersRequest& request) const;
@@ -363,6 +389,9 @@ namespace AlibabaCloud
 			ListUserOrganizationOutcome listUserOrganization(const Model::ListUserOrganizationRequest &request)const;
 			void listUserOrganizationAsync(const Model::ListUserOrganizationRequest& request, const ListUserOrganizationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListUserOrganizationOutcomeCallable listUserOrganizationCallable(const Model::ListUserOrganizationRequest& request) const;
+			TransferPipelineOwnerOutcome transferPipelineOwner(const Model::TransferPipelineOwnerRequest &request)const;
+			void transferPipelineOwnerAsync(const Model::TransferPipelineOwnerRequest& request, const TransferPipelineOwnerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			TransferPipelineOwnerOutcomeCallable transferPipelineOwnerCallable(const Model::TransferPipelineOwnerRequest& request) const;
 			UpdateDevopsProjectOutcome updateDevopsProject(const Model::UpdateDevopsProjectRequest &request)const;
 			void updateDevopsProjectAsync(const Model::UpdateDevopsProjectRequest& request, const UpdateDevopsProjectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateDevopsProjectOutcomeCallable updateDevopsProjectCallable(const Model::UpdateDevopsProjectRequest& request) const;
@@ -372,6 +401,9 @@ namespace AlibabaCloud
 			UpdateDevopsProjectTaskOutcome updateDevopsProjectTask(const Model::UpdateDevopsProjectTaskRequest &request)const;
 			void updateDevopsProjectTaskAsync(const Model::UpdateDevopsProjectTaskRequest& request, const UpdateDevopsProjectTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateDevopsProjectTaskOutcomeCallable updateDevopsProjectTaskCallable(const Model::UpdateDevopsProjectTaskRequest& request) const;
+			UpdatePipelineMemberOutcome updatePipelineMember(const Model::UpdatePipelineMemberRequest &request)const;
+			void updatePipelineMemberAsync(const Model::UpdatePipelineMemberRequest& request, const UpdatePipelineMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdatePipelineMemberOutcomeCallable updatePipelineMemberCallable(const Model::UpdatePipelineMemberRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

devops-rdc/include/alibabacloud/devops-rdc/model/DeletePipelineMemberRequest.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_DEVOPS_RDC_MODEL_DELETEPIPELINEMEMBERREQUEST_H_
+#define ALIBABACLOUD_DEVOPS_RDC_MODEL_DELETEPIPELINEMEMBERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/devops-rdc/Devops_rdcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Devops_rdc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DEVOPS_RDC_EXPORT DeletePipelineMemberRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeletePipelineMemberRequest();
+				~DeletePipelineMemberRequest();
+
+				std::string getUserPk()const;
+				void setUserPk(const std::string& userPk);
+				std::string getUserId()const;
+				void setUserId(const std::string& userId);
+				std::string getOrgId()const;
+				void setOrgId(const std::string& orgId);
+				long getPipelineId()const;
+				void setPipelineId(long pipelineId);
+
+            private:
+				std::string userPk_;
+				std::string userId_;
+				std::string orgId_;
+				long pipelineId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DEVOPS_RDC_MODEL_DELETEPIPELINEMEMBERREQUEST_H_

devops-rdc/include/alibabacloud/devops-rdc/model/DeletePipelineMemberResult.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_DEVOPS_RDC_MODEL_DELETEPIPELINEMEMBERRESULT_H_
+#define ALIBABACLOUD_DEVOPS_RDC_MODEL_DELETEPIPELINEMEMBERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/devops-rdc/Devops_rdcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Devops_rdc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DEVOPS_RDC_EXPORT DeletePipelineMemberResult : public ServiceResult
+			{
+			public:
+
+
+				DeletePipelineMemberResult();
+				explicit DeletePipelineMemberResult(const std::string &payload);
+				~DeletePipelineMemberResult();
+				bool getObject()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool object_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DEVOPS_RDC_MODEL_DELETEPIPELINEMEMBERRESULT_H_

devops-rdc/include/alibabacloud/devops-rdc/model/InsertPipelineMemberRequest.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_DEVOPS_RDC_MODEL_INSERTPIPELINEMEMBERREQUEST_H_
+#define ALIBABACLOUD_DEVOPS_RDC_MODEL_INSERTPIPELINEMEMBERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/devops-rdc/Devops_rdcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Devops_rdc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DEVOPS_RDC_EXPORT InsertPipelineMemberRequest : public RpcServiceRequest
+			{
+
+			public:
+				InsertPipelineMemberRequest();
+				~InsertPipelineMemberRequest();
+
+				std::string getRoleName()const;
+				void setRoleName(const std::string& roleName);
+				std::string getUserPk()const;
+				void setUserPk(const std::string& userPk);
+				std::string getUserId()const;
+				void setUserId(const std::string& userId);
+				std::string getOrgId()const;
+				void setOrgId(const std::string& orgId);
+				long getPipelineId()const;
+				void setPipelineId(long pipelineId);
+
+            private:
+				std::string roleName_;
+				std::string userPk_;
+				std::string userId_;
+				std::string orgId_;
+				long pipelineId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DEVOPS_RDC_MODEL_INSERTPIPELINEMEMBERREQUEST_H_

devops-rdc/include/alibabacloud/devops-rdc/model/InsertPipelineMemberResult.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_DEVOPS_RDC_MODEL_INSERTPIPELINEMEMBERRESULT_H_
+#define ALIBABACLOUD_DEVOPS_RDC_MODEL_INSERTPIPELINEMEMBERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/devops-rdc/Devops_rdcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Devops_rdc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DEVOPS_RDC_EXPORT InsertPipelineMemberResult : public ServiceResult
+			{
+			public:
+
+
+				InsertPipelineMemberResult();
+				explicit InsertPipelineMemberResult(const std::string &payload);
+				~InsertPipelineMemberResult();
+				bool getObject()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool object_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DEVOPS_RDC_MODEL_INSERTPIPELINEMEMBERRESULT_H_

devops-rdc/include/alibabacloud/devops-rdc/model/TransferPipelineOwnerRequest.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_DEVOPS_RDC_MODEL_TRANSFERPIPELINEOWNERREQUEST_H_
+#define ALIBABACLOUD_DEVOPS_RDC_MODEL_TRANSFERPIPELINEOWNERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/devops-rdc/Devops_rdcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Devops_rdc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DEVOPS_RDC_EXPORT TransferPipelineOwnerRequest : public RpcServiceRequest
+			{
+
+			public:
+				TransferPipelineOwnerRequest();
+				~TransferPipelineOwnerRequest();
+
+				std::string getUserPk()const;
+				void setUserPk(const std::string& userPk);
+				std::string getOrgId()const;
+				void setOrgId(const std::string& orgId);
+				long getPipelineId()const;
+				void setPipelineId(long pipelineId);
+				std::string getNewOwnerId()const;
+				void setNewOwnerId(const std::string& newOwnerId);
+
+            private:
+				std::string userPk_;
+				std::string orgId_;
+				long pipelineId_;
+				std::string newOwnerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DEVOPS_RDC_MODEL_TRANSFERPIPELINEOWNERREQUEST_H_

devops-rdc/include/alibabacloud/devops-rdc/model/TransferPipelineOwnerResult.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_DEVOPS_RDC_MODEL_TRANSFERPIPELINEOWNERRESULT_H_
+#define ALIBABACLOUD_DEVOPS_RDC_MODEL_TRANSFERPIPELINEOWNERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/devops-rdc/Devops_rdcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Devops_rdc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DEVOPS_RDC_EXPORT TransferPipelineOwnerResult : public ServiceResult
+			{
+			public:
+
+
+				TransferPipelineOwnerResult();
+				explicit TransferPipelineOwnerResult(const std::string &payload);
+				~TransferPipelineOwnerResult();
+				std::string getObject()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string object_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DEVOPS_RDC_MODEL_TRANSFERPIPELINEOWNERRESULT_H_

devops-rdc/include/alibabacloud/devops-rdc/model/UpdatePipelineMemberRequest.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_DEVOPS_RDC_MODEL_UPDATEPIPELINEMEMBERREQUEST_H_
+#define ALIBABACLOUD_DEVOPS_RDC_MODEL_UPDATEPIPELINEMEMBERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/devops-rdc/Devops_rdcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Devops_rdc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DEVOPS_RDC_EXPORT UpdatePipelineMemberRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdatePipelineMemberRequest();
+				~UpdatePipelineMemberRequest();
+
+				std::string getRoleName()const;
+				void setRoleName(const std::string& roleName);
+				std::string getUserPk()const;
+				void setUserPk(const std::string& userPk);
+				std::string getUserId()const;
+				void setUserId(const std::string& userId);
+				std::string getOrgId()const;
+				void setOrgId(const std::string& orgId);
+				long getPipelineId()const;
+				void setPipelineId(long pipelineId);
+
+            private:
+				std::string roleName_;
+				std::string userPk_;
+				std::string userId_;
+				std::string orgId_;
+				long pipelineId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DEVOPS_RDC_MODEL_UPDATEPIPELINEMEMBERREQUEST_H_

devops-rdc/include/alibabacloud/devops-rdc/model/UpdatePipelineMemberResult.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_DEVOPS_RDC_MODEL_UPDATEPIPELINEMEMBERRESULT_H_
+#define ALIBABACLOUD_DEVOPS_RDC_MODEL_UPDATEPIPELINEMEMBERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/devops-rdc/Devops_rdcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Devops_rdc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DEVOPS_RDC_EXPORT UpdatePipelineMemberResult : public ServiceResult
+			{
+			public:
+
+
+				UpdatePipelineMemberResult();
+				explicit UpdatePipelineMemberResult(const std::string &payload);
+				~UpdatePipelineMemberResult();
+				bool getObject()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool object_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DEVOPS_RDC_MODEL_UPDATEPIPELINEMEMBERRESULT_H_

devops-rdc/src/Devops-rdcClient.cc

@@ -591,6 +591,42 @@ Devops_rdcClient::DeleteDevopsProjectTaskOutcomeCallable Devops_rdcClient::delet
 	return task->get_future();
 }
 
+Devops_rdcClient::DeletePipelineMemberOutcome Devops_rdcClient::deletePipelineMember(const DeletePipelineMemberRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeletePipelineMemberOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeletePipelineMemberOutcome(DeletePipelineMemberResult(outcome.result()));
+	else
+		return DeletePipelineMemberOutcome(outcome.error());
+}
+
+void Devops_rdcClient::deletePipelineMemberAsync(const DeletePipelineMemberRequest& request, const DeletePipelineMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deletePipelineMember(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Devops_rdcClient::DeletePipelineMemberOutcomeCallable Devops_rdcClient::deletePipelineMemberCallable(const DeletePipelineMemberRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeletePipelineMemberOutcome()>>(
+			[this, request]()
+			{
+			return this->deletePipelineMember(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Devops_rdcClient::ExecutePipelineOutcome Devops_rdcClient::executePipeline(const ExecutePipelineRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1095,6 +1131,42 @@ Devops_rdcClient::InsertDevopsUserOutcomeCallable Devops_rdcClient::insertDevops
 	return task->get_future();
 }
 
+Devops_rdcClient::InsertPipelineMemberOutcome Devops_rdcClient::insertPipelineMember(const InsertPipelineMemberRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return InsertPipelineMemberOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return InsertPipelineMemberOutcome(InsertPipelineMemberResult(outcome.result()));
+	else
+		return InsertPipelineMemberOutcome(outcome.error());
+}
+
+void Devops_rdcClient::insertPipelineMemberAsync(const InsertPipelineMemberRequest& request, const InsertPipelineMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, insertPipelineMember(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Devops_rdcClient::InsertPipelineMemberOutcomeCallable Devops_rdcClient::insertPipelineMemberCallable(const InsertPipelineMemberRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<InsertPipelineMemberOutcome()>>(
+			[this, request]()
+			{
+			return this->insertPipelineMember(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Devops_rdcClient::InsertProjectMembersOutcome Devops_rdcClient::insertProjectMembers(const InsertProjectMembersRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1455,6 +1527,42 @@ Devops_rdcClient::ListUserOrganizationOutcomeCallable Devops_rdcClient::listUser
 	return task->get_future();
 }
 
+Devops_rdcClient::TransferPipelineOwnerOutcome Devops_rdcClient::transferPipelineOwner(const TransferPipelineOwnerRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return TransferPipelineOwnerOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return TransferPipelineOwnerOutcome(TransferPipelineOwnerResult(outcome.result()));
+	else
+		return TransferPipelineOwnerOutcome(outcome.error());
+}
+
+void Devops_rdcClient::transferPipelineOwnerAsync(const TransferPipelineOwnerRequest& request, const TransferPipelineOwnerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, transferPipelineOwner(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Devops_rdcClient::TransferPipelineOwnerOutcomeCallable Devops_rdcClient::transferPipelineOwnerCallable(const TransferPipelineOwnerRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<TransferPipelineOwnerOutcome()>>(
+			[this, request]()
+			{
+			return this->transferPipelineOwner(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Devops_rdcClient::UpdateDevopsProjectOutcome Devops_rdcClient::updateDevopsProject(const UpdateDevopsProjectRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1563,3 +1671,39 @@ Devops_rdcClient::UpdateDevopsProjectTaskOutcomeCallable Devops_rdcClient::updat
 	return task->get_future();
 }
 
+Devops_rdcClient::UpdatePipelineMemberOutcome Devops_rdcClient::updatePipelineMember(const UpdatePipelineMemberRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdatePipelineMemberOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdatePipelineMemberOutcome(UpdatePipelineMemberResult(outcome.result()));
+	else
+		return UpdatePipelineMemberOutcome(outcome.error());
+}
+
+void Devops_rdcClient::updatePipelineMemberAsync(const UpdatePipelineMemberRequest& request, const UpdatePipelineMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updatePipelineMember(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Devops_rdcClient::UpdatePipelineMemberOutcomeCallable Devops_rdcClient::updatePipelineMemberCallable(const UpdatePipelineMemberRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdatePipelineMemberOutcome()>>(
+			[this, request]()
+			{
+			return this->updatePipelineMember(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

devops-rdc/src/model/DeletePipelineMemberRequest.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/devops-rdc/model/DeletePipelineMemberRequest.h>
+
+using AlibabaCloud::Devops_rdc::Model::DeletePipelineMemberRequest;
+
+DeletePipelineMemberRequest::DeletePipelineMemberRequest() :
+	RpcServiceRequest("devops-rdc", "2020-03-03", "DeletePipelineMember")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeletePipelineMemberRequest::~DeletePipelineMemberRequest()
+{}
+
+std::string DeletePipelineMemberRequest::getUserPk()const
+{
+	return userPk_;
+}
+
+void DeletePipelineMemberRequest::setUserPk(const std::string& userPk)
+{
+	userPk_ = userPk;
+	setBodyParameter("UserPk", userPk);
+}
+
+std::string DeletePipelineMemberRequest::getUserId()const
+{
+	return userId_;
+}
+
+void DeletePipelineMemberRequest::setUserId(const std::string& userId)
+{
+	userId_ = userId;
+	setBodyParameter("UserId", userId);
+}
+
+std::string DeletePipelineMemberRequest::getOrgId()const
+{
+	return orgId_;
+}
+
+void DeletePipelineMemberRequest::setOrgId(const std::string& orgId)
+{
+	orgId_ = orgId;
+	setParameter("OrgId", orgId);
+}
+
+long DeletePipelineMemberRequest::getPipelineId()const
+{
+	return pipelineId_;
+}
+
+void DeletePipelineMemberRequest::setPipelineId(long pipelineId)
+{
+	pipelineId_ = pipelineId;
+	setParameter("PipelineId", std::to_string(pipelineId));
+}
+

devops-rdc/src/model/DeletePipelineMemberResult.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/devops-rdc/model/DeletePipelineMemberResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Devops_rdc;
+using namespace AlibabaCloud::Devops_rdc::Model;
+
+DeletePipelineMemberResult::DeletePipelineMemberResult() :
+	ServiceResult()
+{}
+
+DeletePipelineMemberResult::DeletePipelineMemberResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeletePipelineMemberResult::~DeletePipelineMemberResult()
+{}
+
+void DeletePipelineMemberResult::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["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Object"].isNull())
+		object_ = value["Object"].asString() == "true";
+
+}
+
+bool DeletePipelineMemberResult::getObject()const
+{
+	return object_;
+}
+
+std::string DeletePipelineMemberResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string DeletePipelineMemberResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool DeletePipelineMemberResult::getSuccess()const
+{
+	return success_;
+}
+

devops-rdc/src/model/InsertPipelineMemberRequest.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/devops-rdc/model/InsertPipelineMemberRequest.h>
+
+using AlibabaCloud::Devops_rdc::Model::InsertPipelineMemberRequest;
+
+InsertPipelineMemberRequest::InsertPipelineMemberRequest() :
+	RpcServiceRequest("devops-rdc", "2020-03-03", "InsertPipelineMember")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+InsertPipelineMemberRequest::~InsertPipelineMemberRequest()
+{}
+
+std::string InsertPipelineMemberRequest::getRoleName()const
+{
+	return roleName_;
+}
+
+void InsertPipelineMemberRequest::setRoleName(const std::string& roleName)
+{
+	roleName_ = roleName;
+	setBodyParameter("RoleName", roleName);
+}
+
+std::string InsertPipelineMemberRequest::getUserPk()const
+{
+	return userPk_;
+}
+
+void InsertPipelineMemberRequest::setUserPk(const std::string& userPk)
+{
+	userPk_ = userPk;
+	setBodyParameter("UserPk", userPk);
+}
+
+std::string InsertPipelineMemberRequest::getUserId()const
+{
+	return userId_;
+}
+
+void InsertPipelineMemberRequest::setUserId(const std::string& userId)
+{
+	userId_ = userId;
+	setBodyParameter("UserId", userId);
+}
+
+std::string InsertPipelineMemberRequest::getOrgId()const
+{
+	return orgId_;
+}
+
+void InsertPipelineMemberRequest::setOrgId(const std::string& orgId)
+{
+	orgId_ = orgId;
+	setParameter("OrgId", orgId);
+}
+
+long InsertPipelineMemberRequest::getPipelineId()const
+{
+	return pipelineId_;
+}
+
+void InsertPipelineMemberRequest::setPipelineId(long pipelineId)
+{
+	pipelineId_ = pipelineId;
+	setParameter("PipelineId", std::to_string(pipelineId));
+}
+

devops-rdc/src/model/InsertPipelineMemberResult.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/devops-rdc/model/InsertPipelineMemberResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Devops_rdc;
+using namespace AlibabaCloud::Devops_rdc::Model;
+
+InsertPipelineMemberResult::InsertPipelineMemberResult() :
+	ServiceResult()
+{}
+
+InsertPipelineMemberResult::InsertPipelineMemberResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+InsertPipelineMemberResult::~InsertPipelineMemberResult()
+{}
+
+void InsertPipelineMemberResult::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["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Object"].isNull())
+		object_ = value["Object"].asString() == "true";
+
+}
+
+bool InsertPipelineMemberResult::getObject()const
+{
+	return object_;
+}
+
+std::string InsertPipelineMemberResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string InsertPipelineMemberResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool InsertPipelineMemberResult::getSuccess()const
+{
+	return success_;
+}
+

devops-rdc/src/model/TransferPipelineOwnerRequest.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/devops-rdc/model/TransferPipelineOwnerRequest.h>
+
+using AlibabaCloud::Devops_rdc::Model::TransferPipelineOwnerRequest;
+
+TransferPipelineOwnerRequest::TransferPipelineOwnerRequest() :
+	RpcServiceRequest("devops-rdc", "2020-03-03", "TransferPipelineOwner")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+TransferPipelineOwnerRequest::~TransferPipelineOwnerRequest()
+{}
+
+std::string TransferPipelineOwnerRequest::getUserPk()const
+{
+	return userPk_;
+}
+
+void TransferPipelineOwnerRequest::setUserPk(const std::string& userPk)
+{
+	userPk_ = userPk;
+	setBodyParameter("UserPk", userPk);
+}
+
+std::string TransferPipelineOwnerRequest::getOrgId()const
+{
+	return orgId_;
+}
+
+void TransferPipelineOwnerRequest::setOrgId(const std::string& orgId)
+{
+	orgId_ = orgId;
+	setParameter("OrgId", orgId);
+}
+
+long TransferPipelineOwnerRequest::getPipelineId()const
+{
+	return pipelineId_;
+}
+
+void TransferPipelineOwnerRequest::setPipelineId(long pipelineId)
+{
+	pipelineId_ = pipelineId;
+	setParameter("PipelineId", std::to_string(pipelineId));
+}
+
+std::string TransferPipelineOwnerRequest::getNewOwnerId()const
+{
+	return newOwnerId_;
+}
+
+void TransferPipelineOwnerRequest::setNewOwnerId(const std::string& newOwnerId)
+{
+	newOwnerId_ = newOwnerId;
+	setBodyParameter("NewOwnerId", newOwnerId);
+}
+

devops-rdc/src/model/TransferPipelineOwnerResult.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/devops-rdc/model/TransferPipelineOwnerResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Devops_rdc;
+using namespace AlibabaCloud::Devops_rdc::Model;
+
+TransferPipelineOwnerResult::TransferPipelineOwnerResult() :
+	ServiceResult()
+{}
+
+TransferPipelineOwnerResult::TransferPipelineOwnerResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+TransferPipelineOwnerResult::~TransferPipelineOwnerResult()
+{}
+
+void TransferPipelineOwnerResult::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["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Object"].isNull())
+		object_ = value["Object"].asString();
+
+}
+
+std::string TransferPipelineOwnerResult::getObject()const
+{
+	return object_;
+}
+
+std::string TransferPipelineOwnerResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string TransferPipelineOwnerResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool TransferPipelineOwnerResult::getSuccess()const
+{
+	return success_;
+}
+

devops-rdc/src/model/UpdatePipelineMemberRequest.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/devops-rdc/model/UpdatePipelineMemberRequest.h>
+
+using AlibabaCloud::Devops_rdc::Model::UpdatePipelineMemberRequest;
+
+UpdatePipelineMemberRequest::UpdatePipelineMemberRequest() :
+	RpcServiceRequest("devops-rdc", "2020-03-03", "UpdatePipelineMember")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+UpdatePipelineMemberRequest::~UpdatePipelineMemberRequest()
+{}
+
+std::string UpdatePipelineMemberRequest::getRoleName()const
+{
+	return roleName_;
+}
+
+void UpdatePipelineMemberRequest::setRoleName(const std::string& roleName)
+{
+	roleName_ = roleName;
+	setBodyParameter("RoleName", roleName);
+}
+
+std::string UpdatePipelineMemberRequest::getUserPk()const
+{
+	return userPk_;
+}
+
+void UpdatePipelineMemberRequest::setUserPk(const std::string& userPk)
+{
+	userPk_ = userPk;
+	setBodyParameter("UserPk", userPk);
+}
+
+std::string UpdatePipelineMemberRequest::getUserId()const
+{
+	return userId_;
+}
+
+void UpdatePipelineMemberRequest::setUserId(const std::string& userId)
+{
+	userId_ = userId;
+	setBodyParameter("UserId", userId);
+}
+
+std::string UpdatePipelineMemberRequest::getOrgId()const
+{
+	return orgId_;
+}
+
+void UpdatePipelineMemberRequest::setOrgId(const std::string& orgId)
+{
+	orgId_ = orgId;
+	setParameter("OrgId", orgId);
+}
+
+long UpdatePipelineMemberRequest::getPipelineId()const
+{
+	return pipelineId_;
+}
+
+void UpdatePipelineMemberRequest::setPipelineId(long pipelineId)
+{
+	pipelineId_ = pipelineId;
+	setParameter("PipelineId", std::to_string(pipelineId));
+}
+

devops-rdc/src/model/UpdatePipelineMemberResult.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/devops-rdc/model/UpdatePipelineMemberResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Devops_rdc;
+using namespace AlibabaCloud::Devops_rdc::Model;
+
+UpdatePipelineMemberResult::UpdatePipelineMemberResult() :
+	ServiceResult()
+{}
+
+UpdatePipelineMemberResult::UpdatePipelineMemberResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdatePipelineMemberResult::~UpdatePipelineMemberResult()
+{}
+
+void UpdatePipelineMemberResult::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["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Object"].isNull())
+		object_ = value["Object"].asString() == "true";
+
+}
+
+bool UpdatePipelineMemberResult::getObject()const
+{
+	return object_;
+}
+
+std::string UpdatePipelineMemberResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string UpdatePipelineMemberResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool UpdatePipelineMemberResult::getSuccess()const
+{
+	return success_;
+}
+

imageprocess/include/alibabacloud/imageprocess/model/DetectLungNoduleResult.h

@@ -48,6 +48,7 @@ namespace AlibabaCloud
 							float x;
 							float y;
 							float z;
+							std::string sOPInstanceUID;
 							float diameter;
 						};
 						std::vector<std::string> origin;

imageprocess/src/model/DetectLungNoduleResult.cc

@@ -72,6 +72,8 @@ void DetectLungNoduleResult::parse(const std::string &payload)
 				elementsObject.imageY = std::stof(allSeriesNodeElementsElement["ImageY"].asString());
 			if(!allSeriesNodeElementsElement["ImageZ"].isNull())
 				elementsObject.imageZ = std::stof(allSeriesNodeElementsElement["ImageZ"].asString());
+			if(!allSeriesNodeElementsElement["SOPInstanceUID"].isNull())
+				elementsObject.sOPInstanceUID = allSeriesNodeElementsElement["SOPInstanceUID"].asString();
 			serieObject.elements.push_back(elementsObject);
 		}
 		auto allOrigin = value["Origin"]["Origin"];

imm/CMakeLists.txt

@@ -176,7 +176,9 @@ set(imm_public_header_model
 	include/alibabacloud/imm/model/UpdateProjectRequest.h
 	include/alibabacloud/imm/model/UpdateProjectResult.h
 	include/alibabacloud/imm/model/UpdateSetRequest.h
-	include/alibabacloud/imm/model/UpdateSetResult.h )
+	include/alibabacloud/imm/model/UpdateSetResult.h
+	include/alibabacloud/imm/model/VideoAnalyseFeedbackRequest.h
+	include/alibabacloud/imm/model/VideoAnalyseFeedbackResult.h )
 
 set(imm_src 
 	src/ImmClient.cc
@@ -335,7 +337,9 @@ set(imm_src
 	src/model/UpdateProjectRequest.cc
 	src/model/UpdateProjectResult.cc
 	src/model/UpdateSetRequest.cc
-	src/model/UpdateSetResult.cc )
+	src/model/UpdateSetResult.cc
+	src/model/VideoAnalyseFeedbackRequest.cc
+	src/model/VideoAnalyseFeedbackResult.cc )
 
 add_library(imm ${LIB_TYPE}
 	${imm_public_header}

imm/include/alibabacloud/imm/ImmClient.h

@@ -178,6 +178,8 @@
 #include "model/UpdateProjectResult.h"
 #include "model/UpdateSetRequest.h"
 #include "model/UpdateSetResult.h"
+#include "model/VideoAnalyseFeedbackRequest.h"
+#include "model/VideoAnalyseFeedbackResult.h"
 
 
 namespace AlibabaCloud
@@ -421,6 +423,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateSetResult> UpdateSetOutcome;
 			typedef std::future<UpdateSetOutcome> UpdateSetOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::UpdateSetRequest&, const UpdateSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateSetAsyncHandler;
+			typedef Outcome<Error, Model::VideoAnalyseFeedbackResult> VideoAnalyseFeedbackOutcome;
+			typedef std::future<VideoAnalyseFeedbackOutcome> VideoAnalyseFeedbackOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::VideoAnalyseFeedbackRequest&, const VideoAnalyseFeedbackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VideoAnalyseFeedbackAsyncHandler;
 
 			ImmClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			ImmClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
@@ -660,6 +665,9 @@ namespace AlibabaCloud
 			UpdateSetOutcome updateSet(const Model::UpdateSetRequest &request)const;
 			void updateSetAsync(const Model::UpdateSetRequest& request, const UpdateSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateSetOutcomeCallable updateSetCallable(const Model::UpdateSetRequest& request) const;
+			VideoAnalyseFeedbackOutcome videoAnalyseFeedback(const Model::VideoAnalyseFeedbackRequest &request)const;
+			void videoAnalyseFeedbackAsync(const Model::VideoAnalyseFeedbackRequest& request, const VideoAnalyseFeedbackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			VideoAnalyseFeedbackOutcomeCallable videoAnalyseFeedbackCallable(const Model::VideoAnalyseFeedbackRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

imm/include/alibabacloud/imm/model/VideoAnalyseFeedbackRequest.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_IMM_MODEL_VIDEOANALYSEFEEDBACKREQUEST_H_
+#define ALIBABACLOUD_IMM_MODEL_VIDEOANALYSEFEEDBACKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imm/ImmExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imm
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMM_EXPORT VideoAnalyseFeedbackRequest : public RpcServiceRequest
+			{
+
+			public:
+				VideoAnalyseFeedbackRequest();
+				~VideoAnalyseFeedbackRequest();
+
+				std::string getNote()const;
+				void setNote(const std::string& note);
+				std::string getProject()const;
+				void setProject(const std::string& project);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getTaskId()const;
+				void setTaskId(const std::string& taskId);
+				std::string getFrames()const;
+				void setFrames(const std::string& frames);
+				std::string getSuggestion()const;
+				void setSuggestion(const std::string& suggestion);
+				std::string getUri()const;
+				void setUri(const std::string& uri);
+				std::string getScenes()const;
+				void setScenes(const std::string& scenes);
+
+            private:
+				std::string note_;
+				std::string project_;
+				std::string accessKeyId_;
+				std::string taskId_;
+				std::string frames_;
+				std::string suggestion_;
+				std::string uri_;
+				std::string scenes_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMM_MODEL_VIDEOANALYSEFEEDBACKREQUEST_H_

imm/include/alibabacloud/imm/model/VideoAnalyseFeedbackResult.h

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

imm/src/ImmClient.cc

@@ -2859,3 +2859,39 @@ ImmClient::UpdateSetOutcomeCallable ImmClient::updateSetCallable(const UpdateSet
 	return task->get_future();
 }
 
+ImmClient::VideoAnalyseFeedbackOutcome ImmClient::videoAnalyseFeedback(const VideoAnalyseFeedbackRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return VideoAnalyseFeedbackOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return VideoAnalyseFeedbackOutcome(VideoAnalyseFeedbackResult(outcome.result()));
+	else
+		return VideoAnalyseFeedbackOutcome(outcome.error());
+}
+
+void ImmClient::videoAnalyseFeedbackAsync(const VideoAnalyseFeedbackRequest& request, const VideoAnalyseFeedbackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, videoAnalyseFeedback(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::VideoAnalyseFeedbackOutcomeCallable ImmClient::videoAnalyseFeedbackCallable(const VideoAnalyseFeedbackRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<VideoAnalyseFeedbackOutcome()>>(
+			[this, request]()
+			{
+			return this->videoAnalyseFeedback(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

imm/src/model/VideoAnalyseFeedbackRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/VideoAnalyseFeedbackRequest.h>
+
+using AlibabaCloud::Imm::Model::VideoAnalyseFeedbackRequest;
+
+VideoAnalyseFeedbackRequest::VideoAnalyseFeedbackRequest() :
+	RpcServiceRequest("imm", "2017-09-06", "VideoAnalyseFeedback")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+VideoAnalyseFeedbackRequest::~VideoAnalyseFeedbackRequest()
+{}
+
+std::string VideoAnalyseFeedbackRequest::getNote()const
+{
+	return note_;
+}
+
+void VideoAnalyseFeedbackRequest::setNote(const std::string& note)
+{
+	note_ = note;
+	setParameter("Note", note);
+}
+
+std::string VideoAnalyseFeedbackRequest::getProject()const
+{
+	return project_;
+}
+
+void VideoAnalyseFeedbackRequest::setProject(const std::string& project)
+{
+	project_ = project;
+	setParameter("Project", project);
+}
+
+std::string VideoAnalyseFeedbackRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void VideoAnalyseFeedbackRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string VideoAnalyseFeedbackRequest::getTaskId()const
+{
+	return taskId_;
+}
+
+void VideoAnalyseFeedbackRequest::setTaskId(const std::string& taskId)
+{
+	taskId_ = taskId;
+	setParameter("TaskId", taskId);
+}
+
+std::string VideoAnalyseFeedbackRequest::getFrames()const
+{
+	return frames_;
+}
+
+void VideoAnalyseFeedbackRequest::setFrames(const std::string& frames)
+{
+	frames_ = frames;
+	setParameter("Frames", frames);
+}
+
+std::string VideoAnalyseFeedbackRequest::getSuggestion()const
+{
+	return suggestion_;
+}
+
+void VideoAnalyseFeedbackRequest::setSuggestion(const std::string& suggestion)
+{
+	suggestion_ = suggestion;
+	setParameter("Suggestion", suggestion);
+}
+
+std::string VideoAnalyseFeedbackRequest::getUri()const
+{
+	return uri_;
+}
+
+void VideoAnalyseFeedbackRequest::setUri(const std::string& uri)
+{
+	uri_ = uri;
+	setParameter("Uri", uri);
+}
+
+std::string VideoAnalyseFeedbackRequest::getScenes()const
+{
+	return scenes_;
+}
+
+void VideoAnalyseFeedbackRequest::setScenes(const std::string& scenes)
+{
+	scenes_ = scenes;
+	setParameter("Scenes", scenes);
+}
+

imm/src/model/VideoAnalyseFeedbackResult.cc

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

r-kvstore/CMakeLists.txt

@@ -21,6 +21,8 @@ set(r-kvstore_public_header
 	include/alibabacloud/r-kvstore/R_kvstoreExport.h )
 
 set(r-kvstore_public_header_model 
+	include/alibabacloud/r-kvstore/model/AddShardingNodeRequest.h
+	include/alibabacloud/r-kvstore/model/AddShardingNodeResult.h
 	include/alibabacloud/r-kvstore/model/AllocateDirectConnectionRequest.h
 	include/alibabacloud/r-kvstore/model/AllocateDirectConnectionResult.h
 	include/alibabacloud/r-kvstore/model/AllocateInstancePublicConnectionRequest.h
@@ -49,6 +51,8 @@ set(r-kvstore_public_header_model
 	include/alibabacloud/r-kvstore/model/DeleteDedicatedUserClusterResult.h
 	include/alibabacloud/r-kvstore/model/DeleteInstanceRequest.h
 	include/alibabacloud/r-kvstore/model/DeleteInstanceResult.h
+	include/alibabacloud/r-kvstore/model/DeleteShardingNodeRequest.h
+	include/alibabacloud/r-kvstore/model/DeleteShardingNodeResult.h
 	include/alibabacloud/r-kvstore/model/DeleteUserClusterHostRequest.h
 	include/alibabacloud/r-kvstore/model/DeleteUserClusterHostResult.h
 	include/alibabacloud/r-kvstore/model/DescribeAccountsRequest.h
@@ -65,6 +69,8 @@ set(r-kvstore_public_header_model
 	include/alibabacloud/r-kvstore/model/DescribeCacheAnalysisReportResult.h
 	include/alibabacloud/r-kvstore/model/DescribeCacheAnalysisReportListRequest.h
 	include/alibabacloud/r-kvstore/model/DescribeCacheAnalysisReportListResult.h
+	include/alibabacloud/r-kvstore/model/DescribeClusterMemberInfoRequest.h
+	include/alibabacloud/r-kvstore/model/DescribeClusterMemberInfoResult.h
 	include/alibabacloud/r-kvstore/model/DescribeDBInstanceNetInfoRequest.h
 	include/alibabacloud/r-kvstore/model/DescribeDBInstanceNetInfoResult.h
 	include/alibabacloud/r-kvstore/model/DescribeDedicatedClusterInstanceListRequest.h
@@ -190,6 +196,8 @@ set(r-kvstore_public_header_model
 
 set(r-kvstore_src 
 	src/R-kvstoreClient.cc
+	src/model/AddShardingNodeRequest.cc
+	src/model/AddShardingNodeResult.cc
 	src/model/AllocateDirectConnectionRequest.cc
 	src/model/AllocateDirectConnectionResult.cc
 	src/model/AllocateInstancePublicConnectionRequest.cc
@@ -218,6 +226,8 @@ set(r-kvstore_src
 	src/model/DeleteDedicatedUserClusterResult.cc
 	src/model/DeleteInstanceRequest.cc
 	src/model/DeleteInstanceResult.cc
+	src/model/DeleteShardingNodeRequest.cc
+	src/model/DeleteShardingNodeResult.cc
 	src/model/DeleteUserClusterHostRequest.cc
 	src/model/DeleteUserClusterHostResult.cc
 	src/model/DescribeAccountsRequest.cc
@@ -234,6 +244,8 @@ set(r-kvstore_src
 	src/model/DescribeCacheAnalysisReportResult.cc
 	src/model/DescribeCacheAnalysisReportListRequest.cc
 	src/model/DescribeCacheAnalysisReportListResult.cc
+	src/model/DescribeClusterMemberInfoRequest.cc
+	src/model/DescribeClusterMemberInfoResult.cc
 	src/model/DescribeDBInstanceNetInfoRequest.cc
 	src/model/DescribeDBInstanceNetInfoResult.cc
 	src/model/DescribeDedicatedClusterInstanceListRequest.cc

r-kvstore/include/alibabacloud/r-kvstore/R_kvstoreClient.h

@@ -22,6 +22,8 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RpcServiceClient.h>
 #include "R_kvstoreExport.h"
+#include "model/AddShardingNodeRequest.h"
+#include "model/AddShardingNodeResult.h"
 #include "model/AllocateDirectConnectionRequest.h"
 #include "model/AllocateDirectConnectionResult.h"
 #include "model/AllocateInstancePublicConnectionRequest.h"
@@ -50,6 +52,8 @@
 #include "model/DeleteDedicatedUserClusterResult.h"
 #include "model/DeleteInstanceRequest.h"
 #include "model/DeleteInstanceResult.h"
+#include "model/DeleteShardingNodeRequest.h"
+#include "model/DeleteShardingNodeResult.h"
 #include "model/DeleteUserClusterHostRequest.h"
 #include "model/DeleteUserClusterHostResult.h"
 #include "model/DescribeAccountsRequest.h"
@@ -66,6 +70,8 @@
 #include "model/DescribeCacheAnalysisReportResult.h"
 #include "model/DescribeCacheAnalysisReportListRequest.h"
 #include "model/DescribeCacheAnalysisReportListResult.h"
+#include "model/DescribeClusterMemberInfoRequest.h"
+#include "model/DescribeClusterMemberInfoResult.h"
 #include "model/DescribeDBInstanceNetInfoRequest.h"
 #include "model/DescribeDBInstanceNetInfoResult.h"
 #include "model/DescribeDedicatedClusterInstanceListRequest.h"
@@ -197,6 +203,9 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_R_KVSTORE_EXPORT R_kvstoreClient : public RpcServiceClient
 		{
 		public:
+			typedef Outcome<Error, Model::AddShardingNodeResult> AddShardingNodeOutcome;
+			typedef std::future<AddShardingNodeOutcome> AddShardingNodeOutcomeCallable;
+			typedef std::function<void(const R_kvstoreClient*, const Model::AddShardingNodeRequest&, const AddShardingNodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddShardingNodeAsyncHandler;
 			typedef Outcome<Error, Model::AllocateDirectConnectionResult> AllocateDirectConnectionOutcome;
 			typedef std::future<AllocateDirectConnectionOutcome> AllocateDirectConnectionOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::AllocateDirectConnectionRequest&, const AllocateDirectConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AllocateDirectConnectionAsyncHandler;
@@ -239,6 +248,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteInstanceResult> DeleteInstanceOutcome;
 			typedef std::future<DeleteInstanceOutcome> DeleteInstanceOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::DeleteInstanceRequest&, const DeleteInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteInstanceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteShardingNodeResult> DeleteShardingNodeOutcome;
+			typedef std::future<DeleteShardingNodeOutcome> DeleteShardingNodeOutcomeCallable;
+			typedef std::function<void(const R_kvstoreClient*, const Model::DeleteShardingNodeRequest&, const DeleteShardingNodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteShardingNodeAsyncHandler;
 			typedef Outcome<Error, Model::DeleteUserClusterHostResult> DeleteUserClusterHostOutcome;
 			typedef std::future<DeleteUserClusterHostOutcome> DeleteUserClusterHostOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::DeleteUserClusterHostRequest&, const DeleteUserClusterHostOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteUserClusterHostAsyncHandler;
@@ -263,6 +275,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeCacheAnalysisReportListResult> DescribeCacheAnalysisReportListOutcome;
 			typedef std::future<DescribeCacheAnalysisReportListOutcome> DescribeCacheAnalysisReportListOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::DescribeCacheAnalysisReportListRequest&, const DescribeCacheAnalysisReportListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCacheAnalysisReportListAsyncHandler;
+			typedef Outcome<Error, Model::DescribeClusterMemberInfoResult> DescribeClusterMemberInfoOutcome;
+			typedef std::future<DescribeClusterMemberInfoOutcome> DescribeClusterMemberInfoOutcomeCallable;
+			typedef std::function<void(const R_kvstoreClient*, const Model::DescribeClusterMemberInfoRequest&, const DescribeClusterMemberInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeClusterMemberInfoAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDBInstanceNetInfoResult> DescribeDBInstanceNetInfoOutcome;
 			typedef std::future<DescribeDBInstanceNetInfoOutcome> DescribeDBInstanceNetInfoOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::DescribeDBInstanceNetInfoRequest&, const DescribeDBInstanceNetInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstanceNetInfoAsyncHandler;
@@ -451,6 +466,9 @@ namespace AlibabaCloud
 			R_kvstoreClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			R_kvstoreClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~R_kvstoreClient();
+			AddShardingNodeOutcome addShardingNode(const Model::AddShardingNodeRequest &request)const;
+			void addShardingNodeAsync(const Model::AddShardingNodeRequest& request, const AddShardingNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddShardingNodeOutcomeCallable addShardingNodeCallable(const Model::AddShardingNodeRequest& request) const;
 			AllocateDirectConnectionOutcome allocateDirectConnection(const Model::AllocateDirectConnectionRequest &request)const;
 			void allocateDirectConnectionAsync(const Model::AllocateDirectConnectionRequest& request, const AllocateDirectConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AllocateDirectConnectionOutcomeCallable allocateDirectConnectionCallable(const Model::AllocateDirectConnectionRequest& request) const;
@@ -493,6 +511,9 @@ namespace AlibabaCloud
 			DeleteInstanceOutcome deleteInstance(const Model::DeleteInstanceRequest &request)const;
 			void deleteInstanceAsync(const Model::DeleteInstanceRequest& request, const DeleteInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteInstanceOutcomeCallable deleteInstanceCallable(const Model::DeleteInstanceRequest& request) const;
+			DeleteShardingNodeOutcome deleteShardingNode(const Model::DeleteShardingNodeRequest &request)const;
+			void deleteShardingNodeAsync(const Model::DeleteShardingNodeRequest& request, const DeleteShardingNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteShardingNodeOutcomeCallable deleteShardingNodeCallable(const Model::DeleteShardingNodeRequest& request) const;
 			DeleteUserClusterHostOutcome deleteUserClusterHost(const Model::DeleteUserClusterHostRequest &request)const;
 			void deleteUserClusterHostAsync(const Model::DeleteUserClusterHostRequest& request, const DeleteUserClusterHostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteUserClusterHostOutcomeCallable deleteUserClusterHostCallable(const Model::DeleteUserClusterHostRequest& request) const;
@@ -517,6 +538,9 @@ namespace AlibabaCloud
 			DescribeCacheAnalysisReportListOutcome describeCacheAnalysisReportList(const Model::DescribeCacheAnalysisReportListRequest &request)const;
 			void describeCacheAnalysisReportListAsync(const Model::DescribeCacheAnalysisReportListRequest& request, const DescribeCacheAnalysisReportListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeCacheAnalysisReportListOutcomeCallable describeCacheAnalysisReportListCallable(const Model::DescribeCacheAnalysisReportListRequest& request) const;
+			DescribeClusterMemberInfoOutcome describeClusterMemberInfo(const Model::DescribeClusterMemberInfoRequest &request)const;
+			void describeClusterMemberInfoAsync(const Model::DescribeClusterMemberInfoRequest& request, const DescribeClusterMemberInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeClusterMemberInfoOutcomeCallable describeClusterMemberInfoCallable(const Model::DescribeClusterMemberInfoRequest& request) const;
 			DescribeDBInstanceNetInfoOutcome describeDBInstanceNetInfo(const Model::DescribeDBInstanceNetInfoRequest &request)const;
 			void describeDBInstanceNetInfoAsync(const Model::DescribeDBInstanceNetInfoRequest& request, const DescribeDBInstanceNetInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDBInstanceNetInfoOutcomeCallable describeDBInstanceNetInfoCallable(const Model::DescribeDBInstanceNetInfoRequest& request) const;

r-kvstore/include/alibabacloud/r-kvstore/model/AddShardingNodeRequest.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_R_KVSTORE_MODEL_ADDSHARDINGNODEREQUEST_H_
+#define ALIBABACLOUD_R_KVSTORE_MODEL_ADDSHARDINGNODEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/r-kvstore/R_kvstoreExport.h>
+
+namespace AlibabaCloud
+{
+	namespace R_kvstore
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_R_KVSTORE_EXPORT AddShardingNodeRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddShardingNodeRequest();
+				~AddShardingNodeRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getCouponNo()const;
+				void setCouponNo(const std::string& couponNo);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				int getShardCount()const;
+				void setShardCount(int shardCount);
+				std::string getBusinessInfo()const;
+				void setBusinessInfo(const std::string& businessInfo);
+				bool getAutoPay()const;
+				void setAutoPay(bool autoPay);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+				std::string getShardClass()const;
+				void setShardClass(const std::string& shardClass);
+
+            private:
+				long resourceOwnerId_;
+				std::string couponNo_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				int shardCount_;
+				std::string businessInfo_;
+				bool autoPay_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string instanceId_;
+				std::string shardClass_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_R_KVSTORE_MODEL_ADDSHARDINGNODEREQUEST_H_

r-kvstore/include/alibabacloud/r-kvstore/model/AddShardingNodeResult.h

@@ -0,0 +1,53 @@
+/*
+ * 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_R_KVSTORE_MODEL_ADDSHARDINGNODERESULT_H_
+#define ALIBABACLOUD_R_KVSTORE_MODEL_ADDSHARDINGNODERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/r-kvstore/R_kvstoreExport.h>
+
+namespace AlibabaCloud
+{
+	namespace R_kvstore
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_R_KVSTORE_EXPORT AddShardingNodeResult : public ServiceResult
+			{
+			public:
+
+
+				AddShardingNodeResult();
+				explicit AddShardingNodeResult(const std::string &payload);
+				~AddShardingNodeResult();
+				std::string getNodeId()const;
+				long getOrderId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string nodeId_;
+				long orderId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_R_KVSTORE_MODEL_ADDSHARDINGNODERESULT_H_

r-kvstore/include/alibabacloud/r-kvstore/model/DeleteShardingNodeRequest.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_R_KVSTORE_MODEL_DELETESHARDINGNODEREQUEST_H_
+#define ALIBABACLOUD_R_KVSTORE_MODEL_DELETESHARDINGNODEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/r-kvstore/R_kvstoreExport.h>
+
+namespace AlibabaCloud
+{
+	namespace R_kvstore
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_R_KVSTORE_EXPORT DeleteShardingNodeRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteShardingNodeRequest();
+				~DeleteShardingNodeRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getNodeId()const;
+				void setNodeId(const std::string& nodeId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+
+            private:
+				long resourceOwnerId_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string nodeId_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string instanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_R_KVSTORE_MODEL_DELETESHARDINGNODEREQUEST_H_

r-kvstore/include/alibabacloud/r-kvstore/model/DeleteShardingNodeResult.h

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

r-kvstore/include/alibabacloud/r-kvstore/model/DescribeAvailableResourceRequest.h

@@ -57,6 +57,8 @@ namespace AlibabaCloud
 				void setOwnerId(long ownerId);
 				std::string getInstanceId()const;
 				void setInstanceId(const std::string& instanceId);
+				std::string getAcceptLanguage()const;
+				void setAcceptLanguage(const std::string& acceptLanguage);
 				std::string getZoneId()const;
 				void setZoneId(const std::string& zoneId);
 				std::string getOrderType()const;
@@ -74,6 +76,7 @@ namespace AlibabaCloud
 				std::string ownerAccount_;
 				long ownerId_;
 				std::string instanceId_;
+				std::string acceptLanguage_;
 				std::string zoneId_;
 				std::string orderType_;
 

r-kvstore/include/alibabacloud/r-kvstore/model/DescribeClusterMemberInfoRequest.h

@@ -0,0 +1,66 @@
+/*
+ * 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_R_KVSTORE_MODEL_DESCRIBECLUSTERMEMBERINFOREQUEST_H_
+#define ALIBABACLOUD_R_KVSTORE_MODEL_DESCRIBECLUSTERMEMBERINFOREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/r-kvstore/R_kvstoreExport.h>
+
+namespace AlibabaCloud
+{
+	namespace R_kvstore
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_R_KVSTORE_EXPORT DescribeClusterMemberInfoRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeClusterMemberInfoRequest();
+				~DescribeClusterMemberInfoRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+
+            private:
+				long resourceOwnerId_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string instanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_R_KVSTORE_MODEL_DESCRIBECLUSTERMEMBERINFOREQUEST_H_

r-kvstore/include/alibabacloud/r-kvstore/model/DescribeClusterMemberInfoResult.h

@@ -0,0 +1,77 @@
+/*
+ * 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_R_KVSTORE_MODEL_DESCRIBECLUSTERMEMBERINFORESULT_H_
+#define ALIBABACLOUD_R_KVSTORE_MODEL_DESCRIBECLUSTERMEMBERINFORESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/r-kvstore/R_kvstoreExport.h>
+
+namespace AlibabaCloud
+{
+	namespace R_kvstore
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_R_KVSTORE_EXPORT DescribeClusterMemberInfoResult : public ServiceResult
+			{
+			public:
+				struct Children
+				{
+					long connections;
+					std::string primaryInsName;
+					std::string health;
+					std::string service;
+					std::string bizType;
+					std::string connType;
+					int diskSizeMB;
+					int creator;
+					std::string lockMode;
+					std::string name;
+					std::string insType;
+					int binlogRetentionDays;
+					long bandWidth;
+					std::string classCode;
+					long capacity;
+					std::string userId;
+					std::string serviceVersion;
+					long id;
+					std::string lockReason;
+					int modifier;
+					int replicaSize;
+					std::string nickname;
+					std::string resourceGroupName;
+				};
+
+
+				DescribeClusterMemberInfoResult();
+				explicit DescribeClusterMemberInfoResult(const std::string &payload);
+				~DescribeClusterMemberInfoResult();
+				std::vector<Children> getClusterChildren()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Children> clusterChildren_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_R_KVSTORE_MODEL_DESCRIBECLUSTERMEMBERINFORESULT_H_

r-kvstore/include/alibabacloud/r-kvstore/model/DescribeInstanceAttributeResult.h

@@ -45,6 +45,7 @@ namespace AlibabaCloud
 					std::string config;
 					long port;
 					std::string hasRenewChangeOrder;
+					int shardCount;
 					std::string connectionDomain;
 					std::string maintainEndTime;
 					long capacity;

r-kvstore/include/alibabacloud/r-kvstore/model/DescribeInstancesResult.h

@@ -46,6 +46,7 @@ namespace AlibabaCloud
 					long port;
 					std::string destroyTime;
 					bool hasRenewChangeOrder;
+					int shardCount;
 					std::string connectionDomain;
 					long capacity;
 					long qPS;
@@ -72,6 +73,7 @@ namespace AlibabaCloud
 					std::string chargeType;
 					std::string nodeType;
 					std::string connectionMode;
+					int proxyCount;
 					std::string vpcCloudInstanceId;
 					std::string regionId;
 				};

r-kvstore/include/alibabacloud/r-kvstore/model/DescribePriceResult.h

@@ -43,10 +43,10 @@ namespace AlibabaCloud
 					};
 					std::vector<std::string> ruleIds1;
 					std::string currency;
-					float tradeAmount;
+					std::string tradeAmount;
 					std::vector<Coupon> coupons;
-					float originalAmount;
-					float discountAmount;
+					std::string originalAmount;
+					std::string discountAmount;
 				};
 				struct Rule
 				{
@@ -58,9 +58,9 @@ namespace AlibabaCloud
 				{
 					std::string instanceId;
 					std::vector<std::string> ruleIds;
-					float tradeAmount;
-					float originalAmount;
-					float discountAmount;
+					std::string tradeAmount;
+					std::string originalAmount;
+					std::string discountAmount;
 				};
 
 

r-kvstore/src/R-kvstoreClient.cc

@@ -51,6 +51,42 @@ R_kvstoreClient::R_kvstoreClient(const std::string & accessKeyId, const std::str
 R_kvstoreClient::~R_kvstoreClient()
 {}
 
+R_kvstoreClient::AddShardingNodeOutcome R_kvstoreClient::addShardingNode(const AddShardingNodeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddShardingNodeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddShardingNodeOutcome(AddShardingNodeResult(outcome.result()));
+	else
+		return AddShardingNodeOutcome(outcome.error());
+}
+
+void R_kvstoreClient::addShardingNodeAsync(const AddShardingNodeRequest& request, const AddShardingNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addShardingNode(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+R_kvstoreClient::AddShardingNodeOutcomeCallable R_kvstoreClient::addShardingNodeCallable(const AddShardingNodeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddShardingNodeOutcome()>>(
+			[this, request]()
+			{
+			return this->addShardingNode(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 R_kvstoreClient::AllocateDirectConnectionOutcome R_kvstoreClient::allocateDirectConnection(const AllocateDirectConnectionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -555,6 +591,42 @@ R_kvstoreClient::DeleteInstanceOutcomeCallable R_kvstoreClient::deleteInstanceCa
 	return task->get_future();
 }
 
+R_kvstoreClient::DeleteShardingNodeOutcome R_kvstoreClient::deleteShardingNode(const DeleteShardingNodeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteShardingNodeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteShardingNodeOutcome(DeleteShardingNodeResult(outcome.result()));
+	else
+		return DeleteShardingNodeOutcome(outcome.error());
+}
+
+void R_kvstoreClient::deleteShardingNodeAsync(const DeleteShardingNodeRequest& request, const DeleteShardingNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteShardingNode(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+R_kvstoreClient::DeleteShardingNodeOutcomeCallable R_kvstoreClient::deleteShardingNodeCallable(const DeleteShardingNodeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteShardingNodeOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteShardingNode(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 R_kvstoreClient::DeleteUserClusterHostOutcome R_kvstoreClient::deleteUserClusterHost(const DeleteUserClusterHostRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -843,6 +915,42 @@ R_kvstoreClient::DescribeCacheAnalysisReportListOutcomeCallable R_kvstoreClient:
 	return task->get_future();
 }
 
+R_kvstoreClient::DescribeClusterMemberInfoOutcome R_kvstoreClient::describeClusterMemberInfo(const DescribeClusterMemberInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeClusterMemberInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeClusterMemberInfoOutcome(DescribeClusterMemberInfoResult(outcome.result()));
+	else
+		return DescribeClusterMemberInfoOutcome(outcome.error());
+}
+
+void R_kvstoreClient::describeClusterMemberInfoAsync(const DescribeClusterMemberInfoRequest& request, const DescribeClusterMemberInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeClusterMemberInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+R_kvstoreClient::DescribeClusterMemberInfoOutcomeCallable R_kvstoreClient::describeClusterMemberInfoCallable(const DescribeClusterMemberInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeClusterMemberInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->describeClusterMemberInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 R_kvstoreClient::DescribeDBInstanceNetInfoOutcome R_kvstoreClient::describeDBInstanceNetInfo(const DescribeDBInstanceNetInfoRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

r-kvstore/src/model/AddShardingNodeRequest.cc

@@ -0,0 +1,161 @@
+/*
+ * 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/r-kvstore/model/AddShardingNodeRequest.h>
+
+using AlibabaCloud::R_kvstore::Model::AddShardingNodeRequest;
+
+AddShardingNodeRequest::AddShardingNodeRequest() :
+	RpcServiceRequest("r-kvstore", "2015-01-01", "AddShardingNode")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AddShardingNodeRequest::~AddShardingNodeRequest()
+{}
+
+long AddShardingNodeRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void AddShardingNodeRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string AddShardingNodeRequest::getCouponNo()const
+{
+	return couponNo_;
+}
+
+void AddShardingNodeRequest::setCouponNo(const std::string& couponNo)
+{
+	couponNo_ = couponNo;
+	setParameter("CouponNo", couponNo);
+}
+
+std::string AddShardingNodeRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void AddShardingNodeRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string AddShardingNodeRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void AddShardingNodeRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+int AddShardingNodeRequest::getShardCount()const
+{
+	return shardCount_;
+}
+
+void AddShardingNodeRequest::setShardCount(int shardCount)
+{
+	shardCount_ = shardCount;
+	setParameter("ShardCount", std::to_string(shardCount));
+}
+
+std::string AddShardingNodeRequest::getBusinessInfo()const
+{
+	return businessInfo_;
+}
+
+void AddShardingNodeRequest::setBusinessInfo(const std::string& businessInfo)
+{
+	businessInfo_ = businessInfo;
+	setParameter("BusinessInfo", businessInfo);
+}
+
+bool AddShardingNodeRequest::getAutoPay()const
+{
+	return autoPay_;
+}
+
+void AddShardingNodeRequest::setAutoPay(bool autoPay)
+{
+	autoPay_ = autoPay;
+	setParameter("AutoPay", autoPay ? "true" : "false");
+}
+
+std::string AddShardingNodeRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void AddShardingNodeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string AddShardingNodeRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void AddShardingNodeRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long AddShardingNodeRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void AddShardingNodeRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string AddShardingNodeRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void AddShardingNodeRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string AddShardingNodeRequest::getShardClass()const
+{
+	return shardClass_;
+}
+
+void AddShardingNodeRequest::setShardClass(const std::string& shardClass)
+{
+	shardClass_ = shardClass;
+	setParameter("ShardClass", shardClass);
+}
+

r-kvstore/src/model/AddShardingNodeResult.cc

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

r-kvstore/src/model/DeleteShardingNodeRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/r-kvstore/model/DeleteShardingNodeRequest.h>
+
+using AlibabaCloud::R_kvstore::Model::DeleteShardingNodeRequest;
+
+DeleteShardingNodeRequest::DeleteShardingNodeRequest() :
+	RpcServiceRequest("r-kvstore", "2015-01-01", "DeleteShardingNode")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteShardingNodeRequest::~DeleteShardingNodeRequest()
+{}
+
+long DeleteShardingNodeRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DeleteShardingNodeRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DeleteShardingNodeRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DeleteShardingNodeRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DeleteShardingNodeRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DeleteShardingNodeRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DeleteShardingNodeRequest::getNodeId()const
+{
+	return nodeId_;
+}
+
+void DeleteShardingNodeRequest::setNodeId(const std::string& nodeId)
+{
+	nodeId_ = nodeId;
+	setParameter("NodeId", nodeId);
+}
+
+std::string DeleteShardingNodeRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DeleteShardingNodeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DeleteShardingNodeRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DeleteShardingNodeRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DeleteShardingNodeRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DeleteShardingNodeRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DeleteShardingNodeRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void DeleteShardingNodeRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+

r-kvstore/src/model/DeleteShardingNodeResult.cc

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

r-kvstore/src/model/DescribeAvailableResourceRequest.cc

@@ -148,6 +148,17 @@ void DescribeAvailableResourceRequest::setInstanceId(const std::string& instance
 	setParameter("InstanceId", instanceId);
 }
 
+std::string DescribeAvailableResourceRequest::getAcceptLanguage()const
+{
+	return acceptLanguage_;
+}
+
+void DescribeAvailableResourceRequest::setAcceptLanguage(const std::string& acceptLanguage)
+{
+	acceptLanguage_ = acceptLanguage;
+	setParameter("AcceptLanguage", acceptLanguage);
+}
+
 std::string DescribeAvailableResourceRequest::getZoneId()const
 {
 	return zoneId_;

r-kvstore/src/model/DescribeClusterMemberInfoRequest.cc

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/r-kvstore/model/DescribeClusterMemberInfoRequest.h>
+
+using AlibabaCloud::R_kvstore::Model::DescribeClusterMemberInfoRequest;
+
+DescribeClusterMemberInfoRequest::DescribeClusterMemberInfoRequest() :
+	RpcServiceRequest("r-kvstore", "2015-01-01", "DescribeClusterMemberInfo")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeClusterMemberInfoRequest::~DescribeClusterMemberInfoRequest()
+{}
+
+long DescribeClusterMemberInfoRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeClusterMemberInfoRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeClusterMemberInfoRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeClusterMemberInfoRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeClusterMemberInfoRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeClusterMemberInfoRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeClusterMemberInfoRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeClusterMemberInfoRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeClusterMemberInfoRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeClusterMemberInfoRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DescribeClusterMemberInfoRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeClusterMemberInfoRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeClusterMemberInfoRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void DescribeClusterMemberInfoRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+

r-kvstore/src/model/DescribeClusterMemberInfoResult.cc

@@ -0,0 +1,101 @@
+/*
+ * 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/r-kvstore/model/DescribeClusterMemberInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::R_kvstore;
+using namespace AlibabaCloud::R_kvstore::Model;
+
+DescribeClusterMemberInfoResult::DescribeClusterMemberInfoResult() :
+	ServiceResult()
+{}
+
+DescribeClusterMemberInfoResult::DescribeClusterMemberInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeClusterMemberInfoResult::~DescribeClusterMemberInfoResult()
+{}
+
+void DescribeClusterMemberInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allClusterChildrenNode = value["ClusterChildren"]["Children"];
+	for (auto valueClusterChildrenChildren : allClusterChildrenNode)
+	{
+		Children clusterChildrenObject;
+		if(!valueClusterChildrenChildren["Id"].isNull())
+			clusterChildrenObject.id = std::stol(valueClusterChildrenChildren["Id"].asString());
+		if(!valueClusterChildrenChildren["Name"].isNull())
+			clusterChildrenObject.name = valueClusterChildrenChildren["Name"].asString();
+		if(!valueClusterChildrenChildren["BizType"].isNull())
+			clusterChildrenObject.bizType = valueClusterChildrenChildren["BizType"].asString();
+		if(!valueClusterChildrenChildren["ReplicaSize"].isNull())
+			clusterChildrenObject.replicaSize = std::stoi(valueClusterChildrenChildren["ReplicaSize"].asString());
+		if(!valueClusterChildrenChildren["Modifier"].isNull())
+			clusterChildrenObject.modifier = std::stoi(valueClusterChildrenChildren["Modifier"].asString());
+		if(!valueClusterChildrenChildren["ServiceVersion"].isNull())
+			clusterChildrenObject.serviceVersion = valueClusterChildrenChildren["ServiceVersion"].asString();
+		if(!valueClusterChildrenChildren["ConnType"].isNull())
+			clusterChildrenObject.connType = valueClusterChildrenChildren["ConnType"].asString();
+		if(!valueClusterChildrenChildren["DiskSizeMB"].isNull())
+			clusterChildrenObject.diskSizeMB = std::stoi(valueClusterChildrenChildren["DiskSizeMB"].asString());
+		if(!valueClusterChildrenChildren["InsType"].isNull())
+			clusterChildrenObject.insType = valueClusterChildrenChildren["InsType"].asString();
+		if(!valueClusterChildrenChildren["Nickname"].isNull())
+			clusterChildrenObject.nickname = valueClusterChildrenChildren["Nickname"].asString();
+		if(!valueClusterChildrenChildren["PrimaryInsName"].isNull())
+			clusterChildrenObject.primaryInsName = valueClusterChildrenChildren["PrimaryInsName"].asString();
+		if(!valueClusterChildrenChildren["ClassCode"].isNull())
+			clusterChildrenObject.classCode = valueClusterChildrenChildren["ClassCode"].asString();
+		if(!valueClusterChildrenChildren["Creator"].isNull())
+			clusterChildrenObject.creator = std::stoi(valueClusterChildrenChildren["Creator"].asString());
+		if(!valueClusterChildrenChildren["ResourceGroupName"].isNull())
+			clusterChildrenObject.resourceGroupName = valueClusterChildrenChildren["ResourceGroupName"].asString();
+		if(!valueClusterChildrenChildren["LockMode"].isNull())
+			clusterChildrenObject.lockMode = valueClusterChildrenChildren["LockMode"].asString();
+		if(!valueClusterChildrenChildren["Health"].isNull())
+			clusterChildrenObject.health = valueClusterChildrenChildren["Health"].asString();
+		if(!valueClusterChildrenChildren["BinlogRetentionDays"].isNull())
+			clusterChildrenObject.binlogRetentionDays = std::stoi(valueClusterChildrenChildren["BinlogRetentionDays"].asString());
+		if(!valueClusterChildrenChildren["UserId"].isNull())
+			clusterChildrenObject.userId = valueClusterChildrenChildren["UserId"].asString();
+		if(!valueClusterChildrenChildren["LockReason"].isNull())
+			clusterChildrenObject.lockReason = valueClusterChildrenChildren["LockReason"].asString();
+		if(!valueClusterChildrenChildren["Service"].isNull())
+			clusterChildrenObject.service = valueClusterChildrenChildren["Service"].asString();
+		if(!valueClusterChildrenChildren["Capacity"].isNull())
+			clusterChildrenObject.capacity = std::stol(valueClusterChildrenChildren["Capacity"].asString());
+		if(!valueClusterChildrenChildren["BandWidth"].isNull())
+			clusterChildrenObject.bandWidth = std::stol(valueClusterChildrenChildren["BandWidth"].asString());
+		if(!valueClusterChildrenChildren["Connections"].isNull())
+			clusterChildrenObject.connections = std::stol(valueClusterChildrenChildren["Connections"].asString());
+		clusterChildren_.push_back(clusterChildrenObject);
+	}
+
+}
+
+std::vector<DescribeClusterMemberInfoResult::Children> DescribeClusterMemberInfoResult::getClusterChildren()const
+{
+	return clusterChildren_;
+}
+

r-kvstore/src/model/DescribeInstanceAttributeResult.cc

@@ -123,6 +123,8 @@ void DescribeInstanceAttributeResult::parse(const std::string &payload)
 			instancesObject.instanceReleaseProtection = valueInstancesDBInstanceAttribute["InstanceReleaseProtection"].asString() == "true";
 		if(!valueInstancesDBInstanceAttribute["ResourceGroupId"].isNull())
 			instancesObject.resourceGroupId = valueInstancesDBInstanceAttribute["ResourceGroupId"].asString();
+		if(!valueInstancesDBInstanceAttribute["ShardCount"].isNull())
+			instancesObject.shardCount = std::stoi(valueInstancesDBInstanceAttribute["ShardCount"].asString());
 		auto allTagsNode = allInstancesNode["Tags"]["Tag"];
 		for (auto allInstancesNodeTagsTag : allTagsNode)
 		{

r-kvstore/src/model/DescribeInstancesResult.cc

@@ -111,6 +111,10 @@ void DescribeInstancesResult::parse(const std::string &payload)
 			instancesObject.vpcCloudInstanceId = valueInstancesKVStoreInstance["VpcCloudInstanceId"].asString();
 		if(!valueInstancesKVStoreInstance["ResourceGroupId"].isNull())
 			instancesObject.resourceGroupId = valueInstancesKVStoreInstance["ResourceGroupId"].asString();
+		if(!valueInstancesKVStoreInstance["ShardCount"].isNull())
+			instancesObject.shardCount = std::stoi(valueInstancesKVStoreInstance["ShardCount"].asString());
+		if(!valueInstancesKVStoreInstance["ProxyCount"].isNull())
+			instancesObject.proxyCount = std::stoi(valueInstancesKVStoreInstance["ProxyCount"].asString());
 		auto allTagsNode = allInstancesNode["Tags"]["Tag"];
 		for (auto allInstancesNodeTagsTag : allTagsNode)
 		{

r-kvstore/src/model/DescribePriceResult.cc

@@ -56,11 +56,11 @@ void DescribePriceResult::parse(const std::string &payload)
 	{
 		SubOrder subOrdersObject;
 		if(!valueSubOrdersSubOrder["OriginalAmount"].isNull())
-			subOrdersObject.originalAmount = std::stof(valueSubOrdersSubOrder["OriginalAmount"].asString());
+			subOrdersObject.originalAmount = valueSubOrdersSubOrder["OriginalAmount"].asString();
 		if(!valueSubOrdersSubOrder["TradeAmount"].isNull())
-			subOrdersObject.tradeAmount = std::stof(valueSubOrdersSubOrder["TradeAmount"].asString());
+			subOrdersObject.tradeAmount = valueSubOrdersSubOrder["TradeAmount"].asString();
 		if(!valueSubOrdersSubOrder["DiscountAmount"].isNull())
-			subOrdersObject.discountAmount = std::stof(valueSubOrdersSubOrder["DiscountAmount"].asString());
+			subOrdersObject.discountAmount = valueSubOrdersSubOrder["DiscountAmount"].asString();
 		if(!valueSubOrdersSubOrder["InstanceId"].isNull())
 			subOrdersObject.instanceId = valueSubOrdersSubOrder["InstanceId"].asString();
 		auto allRuleIds = value["RuleIds"]["RuleId"];
@@ -70,11 +70,11 @@ void DescribePriceResult::parse(const std::string &payload)
 	}
 	auto orderNode = value["Order"];
 	if(!orderNode["OriginalAmount"].isNull())
-		order_.originalAmount = std::stof(orderNode["OriginalAmount"].asString());
+		order_.originalAmount = orderNode["OriginalAmount"].asString();
 	if(!orderNode["TradeAmount"].isNull())
-		order_.tradeAmount = std::stof(orderNode["TradeAmount"].asString());
+		order_.tradeAmount = orderNode["TradeAmount"].asString();
 	if(!orderNode["DiscountAmount"].isNull())
-		order_.discountAmount = std::stof(orderNode["DiscountAmount"].asString());
+		order_.discountAmount = orderNode["DiscountAmount"].asString();
 	if(!orderNode["Currency"].isNull())
 		order_.currency = orderNode["Currency"].asString();
 	auto allCouponsNode = orderNode["Coupons"]["Coupon"];

sgw/CMakeLists.txt

@@ -0,0 +1,542 @@
+#
+# 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.
+#
+
+set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
+
+set(sgw_public_header 
+	include/alibabacloud/sgw/SgwClient.h
+	include/alibabacloud/sgw/SgwExport.h )
+
+set(sgw_public_header_model 
+	include/alibabacloud/sgw/model/ActivateAllInOneGatewayRequest.h
+	include/alibabacloud/sgw/model/ActivateAllInOneGatewayResult.h
+	include/alibabacloud/sgw/model/ActivateGatewayRequest.h
+	include/alibabacloud/sgw/model/ActivateGatewayResult.h
+	include/alibabacloud/sgw/model/AddSharesToExpressSyncRequest.h
+	include/alibabacloud/sgw/model/AddSharesToExpressSyncResult.h
+	include/alibabacloud/sgw/model/AddTagsToGatewayRequest.h
+	include/alibabacloud/sgw/model/AddTagsToGatewayResult.h
+	include/alibabacloud/sgw/model/CheckActivationKeyRequest.h
+	include/alibabacloud/sgw/model/CheckActivationKeyResult.h
+	include/alibabacloud/sgw/model/CheckBlockVolumeNameRequest.h
+	include/alibabacloud/sgw/model/CheckBlockVolumeNameResult.h
+	include/alibabacloud/sgw/model/CheckGatewayEssdSupportRequest.h
+	include/alibabacloud/sgw/model/CheckGatewayEssdSupportResult.h
+	include/alibabacloud/sgw/model/CheckMnsServiceRequest.h
+	include/alibabacloud/sgw/model/CheckMnsServiceResult.h
+	include/alibabacloud/sgw/model/CheckRoleRequest.h
+	include/alibabacloud/sgw/model/CheckRoleResult.h
+	include/alibabacloud/sgw/model/CheckSlrRoleRequest.h
+	include/alibabacloud/sgw/model/CheckSlrRoleResult.h
+	include/alibabacloud/sgw/model/CheckUpgradeVersionRequest.h
+	include/alibabacloud/sgw/model/CheckUpgradeVersionResult.h
+	include/alibabacloud/sgw/model/CreateCacheRequest.h
+	include/alibabacloud/sgw/model/CreateCacheResult.h
+	include/alibabacloud/sgw/model/CreateExpressSyncRequest.h
+	include/alibabacloud/sgw/model/CreateExpressSyncResult.h
+	include/alibabacloud/sgw/model/CreateGatewayRequest.h
+	include/alibabacloud/sgw/model/CreateGatewayResult.h
+	include/alibabacloud/sgw/model/CreateGatewayBlockVolumeRequest.h
+	include/alibabacloud/sgw/model/CreateGatewayBlockVolumeResult.h
+	include/alibabacloud/sgw/model/CreateGatewayCacheDiskRequest.h
+	include/alibabacloud/sgw/model/CreateGatewayCacheDiskResult.h
+	include/alibabacloud/sgw/model/CreateGatewayFileShareRequest.h
+	include/alibabacloud/sgw/model/CreateGatewayFileShareResult.h
+	include/alibabacloud/sgw/model/CreateGatewayLoggingRequest.h
+	include/alibabacloud/sgw/model/CreateGatewayLoggingResult.h
+	include/alibabacloud/sgw/model/CreateGatewaySMBUserRequest.h
+	include/alibabacloud/sgw/model/CreateGatewaySMBUserResult.h
+	include/alibabacloud/sgw/model/CreateStorageBundleRequest.h
+	include/alibabacloud/sgw/model/CreateStorageBundleResult.h
+	include/alibabacloud/sgw/model/DeleteExpressSyncRequest.h
+	include/alibabacloud/sgw/model/DeleteExpressSyncResult.h
+	include/alibabacloud/sgw/model/DeleteGatewayRequest.h
+	include/alibabacloud/sgw/model/DeleteGatewayResult.h
+	include/alibabacloud/sgw/model/DeleteGatewayBlockVolumesRequest.h
+	include/alibabacloud/sgw/model/DeleteGatewayBlockVolumesResult.h
+	include/alibabacloud/sgw/model/DeleteGatewayCacheDiskRequest.h
+	include/alibabacloud/sgw/model/DeleteGatewayCacheDiskResult.h
+	include/alibabacloud/sgw/model/DeleteGatewayFileSharesRequest.h
+	include/alibabacloud/sgw/model/DeleteGatewayFileSharesResult.h
+	include/alibabacloud/sgw/model/DeleteGatewayLoggingRequest.h
+	include/alibabacloud/sgw/model/DeleteGatewayLoggingResult.h
+	include/alibabacloud/sgw/model/DeleteGatewaySMBUserRequest.h
+	include/alibabacloud/sgw/model/DeleteGatewaySMBUserResult.h
+	include/alibabacloud/sgw/model/DeleteStorageBundleRequest.h
+	include/alibabacloud/sgw/model/DeleteStorageBundleResult.h
+	include/alibabacloud/sgw/model/DeployCacheDiskRequest.h
+	include/alibabacloud/sgw/model/DeployCacheDiskResult.h
+	include/alibabacloud/sgw/model/DeployGatewayRequest.h
+	include/alibabacloud/sgw/model/DeployGatewayResult.h
+	include/alibabacloud/sgw/model/DescribeAccountConfigRequest.h
+	include/alibabacloud/sgw/model/DescribeAccountConfigResult.h
+	include/alibabacloud/sgw/model/DescribeBlockVolumeSnapshotsRequest.h
+	include/alibabacloud/sgw/model/DescribeBlockVolumeSnapshotsResult.h
+	include/alibabacloud/sgw/model/DescribeDashboardRequest.h
+	include/alibabacloud/sgw/model/DescribeDashboardResult.h
+	include/alibabacloud/sgw/model/DescribeExpireCachesRequest.h
+	include/alibabacloud/sgw/model/DescribeExpireCachesResult.h
+	include/alibabacloud/sgw/model/DescribeExpressSyncSharesRequest.h
+	include/alibabacloud/sgw/model/DescribeExpressSyncSharesResult.h
+	include/alibabacloud/sgw/model/DescribeExpressSyncsRequest.h
+	include/alibabacloud/sgw/model/DescribeExpressSyncsResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayADInfoRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayADInfoResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayActionsRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayActionsResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayAuthInfoRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayAuthInfoResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayBlockVolumesRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayBlockVolumesResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayBucketCachesRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayBucketCachesResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayCachesRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayCachesResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayCapacityLimitRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayCapacityLimitResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayCategoriesRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayCategoriesResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayClassesRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayClassesResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayCredentialRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayCredentialResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayDNSRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayDNSResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayFileSharesRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayFileSharesResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayFileStatusRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayFileStatusResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayImagesRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayImagesResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayInfoRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayInfoResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayLDAPInfoRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayLDAPInfoResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayLocationsRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayLocationsResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayLoggingRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayLoggingResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayLogsRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayLogsResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayModificationClassesRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayModificationClassesResult.h
+	include/alibabacloud/sgw/model/DescribeGatewaySMBUsersRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewaySMBUsersResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayStatisticsRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayStatisticsResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayStockRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayStockResult.h
+	include/alibabacloud/sgw/model/DescribeGatewayTypesRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewayTypesResult.h
+	include/alibabacloud/sgw/model/DescribeGatewaysRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewaysResult.h
+	include/alibabacloud/sgw/model/DescribeGatewaysForCmsRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewaysForCmsResult.h
+	include/alibabacloud/sgw/model/DescribeGatewaysTagsRequest.h
+	include/alibabacloud/sgw/model/DescribeGatewaysTagsResult.h
+	include/alibabacloud/sgw/model/DescribeKmsKeyRequest.h
+	include/alibabacloud/sgw/model/DescribeKmsKeyResult.h
+	include/alibabacloud/sgw/model/DescribeMqttConfigRequest.h
+	include/alibabacloud/sgw/model/DescribeMqttConfigResult.h
+	include/alibabacloud/sgw/model/DescribeOssBucketInfoRequest.h
+	include/alibabacloud/sgw/model/DescribeOssBucketInfoResult.h
+	include/alibabacloud/sgw/model/DescribeOssBucketsRequest.h
+	include/alibabacloud/sgw/model/DescribeOssBucketsResult.h
+	include/alibabacloud/sgw/model/DescribePayAsYouGoPriceRequest.h
+	include/alibabacloud/sgw/model/DescribePayAsYouGoPriceResult.h
+	include/alibabacloud/sgw/model/DescribeRegionsRequest.h
+	include/alibabacloud/sgw/model/DescribeRegionsResult.h
+	include/alibabacloud/sgw/model/DescribeSharesBucketInfoForExpressSyncRequest.h
+	include/alibabacloud/sgw/model/DescribeSharesBucketInfoForExpressSyncResult.h
+	include/alibabacloud/sgw/model/DescribeStorageBundleRequest.h
+	include/alibabacloud/sgw/model/DescribeStorageBundleResult.h
+	include/alibabacloud/sgw/model/DescribeStorageBundlesRequest.h
+	include/alibabacloud/sgw/model/DescribeStorageBundlesResult.h
+	include/alibabacloud/sgw/model/DescribeSubscriptionPriceRequest.h
+	include/alibabacloud/sgw/model/DescribeSubscriptionPriceResult.h
+	include/alibabacloud/sgw/model/DescribeTasksRequest.h
+	include/alibabacloud/sgw/model/DescribeTasksResult.h
+	include/alibabacloud/sgw/model/DescribeUserBusinessStatusRequest.h
+	include/alibabacloud/sgw/model/DescribeUserBusinessStatusResult.h
+	include/alibabacloud/sgw/model/DescribeVSwitchesRequest.h
+	include/alibabacloud/sgw/model/DescribeVSwitchesResult.h
+	include/alibabacloud/sgw/model/DescribeVpcsRequest.h
+	include/alibabacloud/sgw/model/DescribeVpcsResult.h
+	include/alibabacloud/sgw/model/DescribeZonesRequest.h
+	include/alibabacloud/sgw/model/DescribeZonesResult.h
+	include/alibabacloud/sgw/model/DisableGatewayLoggingRequest.h
+	include/alibabacloud/sgw/model/DisableGatewayLoggingResult.h
+	include/alibabacloud/sgw/model/EnableGatewayLoggingRequest.h
+	include/alibabacloud/sgw/model/EnableGatewayLoggingResult.h
+	include/alibabacloud/sgw/model/ExpandCacheDiskRequest.h
+	include/alibabacloud/sgw/model/ExpandCacheDiskResult.h
+	include/alibabacloud/sgw/model/ExpandGatewayNetworkBandwidthRequest.h
+	include/alibabacloud/sgw/model/ExpandGatewayNetworkBandwidthResult.h
+	include/alibabacloud/sgw/model/GenerateGatewayTokenRequest.h
+	include/alibabacloud/sgw/model/GenerateGatewayTokenResult.h
+	include/alibabacloud/sgw/model/GenerateMqttTokenRequest.h
+	include/alibabacloud/sgw/model/GenerateMqttTokenResult.h
+	include/alibabacloud/sgw/model/GenerateStsTokenRequest.h
+	include/alibabacloud/sgw/model/GenerateStsTokenResult.h
+	include/alibabacloud/sgw/model/ListTagResourcesRequest.h
+	include/alibabacloud/sgw/model/ListTagResourcesResult.h
+	include/alibabacloud/sgw/model/ModifyGatewayRequest.h
+	include/alibabacloud/sgw/model/ModifyGatewayResult.h
+	include/alibabacloud/sgw/model/ModifyGatewayBlockVolumeRequest.h
+	include/alibabacloud/sgw/model/ModifyGatewayBlockVolumeResult.h
+	include/alibabacloud/sgw/model/ModifyGatewayClassRequest.h
+	include/alibabacloud/sgw/model/ModifyGatewayClassResult.h
+	include/alibabacloud/sgw/model/ModifyGatewayFileShareRequest.h
+	include/alibabacloud/sgw/model/ModifyGatewayFileShareResult.h
+	include/alibabacloud/sgw/model/ModifyStorageBundleRequest.h
+	include/alibabacloud/sgw/model/ModifyStorageBundleResult.h
+	include/alibabacloud/sgw/model/OperateGatewayRequest.h
+	include/alibabacloud/sgw/model/OperateGatewayResult.h
+	include/alibabacloud/sgw/model/ReleaseServiceRequest.h
+	include/alibabacloud/sgw/model/ReleaseServiceResult.h
+	include/alibabacloud/sgw/model/RemoveSharesFromExpressSyncRequest.h
+	include/alibabacloud/sgw/model/RemoveSharesFromExpressSyncResult.h
+	include/alibabacloud/sgw/model/RemoveTagsFromGatewayRequest.h
+	include/alibabacloud/sgw/model/RemoveTagsFromGatewayResult.h
+	include/alibabacloud/sgw/model/ReportBlockVolumesRequest.h
+	include/alibabacloud/sgw/model/ReportBlockVolumesResult.h
+	include/alibabacloud/sgw/model/ReportFileSharesRequest.h
+	include/alibabacloud/sgw/model/ReportFileSharesResult.h
+	include/alibabacloud/sgw/model/ReportGatewayInfoRequest.h
+	include/alibabacloud/sgw/model/ReportGatewayInfoResult.h
+	include/alibabacloud/sgw/model/ReportGatewayUsageRequest.h
+	include/alibabacloud/sgw/model/ReportGatewayUsageResult.h
+	include/alibabacloud/sgw/model/ResetGatewayPasswordRequest.h
+	include/alibabacloud/sgw/model/ResetGatewayPasswordResult.h
+	include/alibabacloud/sgw/model/RestartFileSharesRequest.h
+	include/alibabacloud/sgw/model/RestartFileSharesResult.h
+	include/alibabacloud/sgw/model/SetGatewayADInfoRequest.h
+	include/alibabacloud/sgw/model/SetGatewayADInfoResult.h
+	include/alibabacloud/sgw/model/SetGatewayDNSRequest.h
+	include/alibabacloud/sgw/model/SetGatewayDNSResult.h
+	include/alibabacloud/sgw/model/SetGatewayLDAPInfoRequest.h
+	include/alibabacloud/sgw/model/SetGatewayLDAPInfoResult.h
+	include/alibabacloud/sgw/model/SwitchGatewayExpirationPolicyRequest.h
+	include/alibabacloud/sgw/model/SwitchGatewayExpirationPolicyResult.h
+	include/alibabacloud/sgw/model/SwitchToSubscriptionRequest.h
+	include/alibabacloud/sgw/model/SwitchToSubscriptionResult.h
+	include/alibabacloud/sgw/model/TagResourcesRequest.h
+	include/alibabacloud/sgw/model/TagResourcesResult.h
+	include/alibabacloud/sgw/model/UntagResourcesRequest.h
+	include/alibabacloud/sgw/model/UntagResourcesResult.h
+	include/alibabacloud/sgw/model/UpdateGatewayBlockVolumeRequest.h
+	include/alibabacloud/sgw/model/UpdateGatewayBlockVolumeResult.h
+	include/alibabacloud/sgw/model/UpdateGatewayFileShareRequest.h
+	include/alibabacloud/sgw/model/UpdateGatewayFileShareResult.h
+	include/alibabacloud/sgw/model/UpgradeGatewayRequest.h
+	include/alibabacloud/sgw/model/UpgradeGatewayResult.h
+	include/alibabacloud/sgw/model/UploadGatewayLogRequest.h
+	include/alibabacloud/sgw/model/UploadGatewayLogResult.h
+	include/alibabacloud/sgw/model/ValidateExpressSyncConfigRequest.h
+	include/alibabacloud/sgw/model/ValidateExpressSyncConfigResult.h
+	include/alibabacloud/sgw/model/ValidateGatewayNameRequest.h
+	include/alibabacloud/sgw/model/ValidateGatewayNameResult.h )
+
+set(sgw_src 
+	src/SgwClient.cc
+	src/model/ActivateAllInOneGatewayRequest.cc
+	src/model/ActivateAllInOneGatewayResult.cc
+	src/model/ActivateGatewayRequest.cc
+	src/model/ActivateGatewayResult.cc
+	src/model/AddSharesToExpressSyncRequest.cc
+	src/model/AddSharesToExpressSyncResult.cc
+	src/model/AddTagsToGatewayRequest.cc
+	src/model/AddTagsToGatewayResult.cc
+	src/model/CheckActivationKeyRequest.cc
+	src/model/CheckActivationKeyResult.cc
+	src/model/CheckBlockVolumeNameRequest.cc
+	src/model/CheckBlockVolumeNameResult.cc
+	src/model/CheckGatewayEssdSupportRequest.cc
+	src/model/CheckGatewayEssdSupportResult.cc
+	src/model/CheckMnsServiceRequest.cc
+	src/model/CheckMnsServiceResult.cc
+	src/model/CheckRoleRequest.cc
+	src/model/CheckRoleResult.cc
+	src/model/CheckSlrRoleRequest.cc
+	src/model/CheckSlrRoleResult.cc
+	src/model/CheckUpgradeVersionRequest.cc
+	src/model/CheckUpgradeVersionResult.cc
+	src/model/CreateCacheRequest.cc
+	src/model/CreateCacheResult.cc
+	src/model/CreateExpressSyncRequest.cc
+	src/model/CreateExpressSyncResult.cc
+	src/model/CreateGatewayRequest.cc
+	src/model/CreateGatewayResult.cc
+	src/model/CreateGatewayBlockVolumeRequest.cc
+	src/model/CreateGatewayBlockVolumeResult.cc
+	src/model/CreateGatewayCacheDiskRequest.cc
+	src/model/CreateGatewayCacheDiskResult.cc
+	src/model/CreateGatewayFileShareRequest.cc
+	src/model/CreateGatewayFileShareResult.cc
+	src/model/CreateGatewayLoggingRequest.cc
+	src/model/CreateGatewayLoggingResult.cc
+	src/model/CreateGatewaySMBUserRequest.cc
+	src/model/CreateGatewaySMBUserResult.cc
+	src/model/CreateStorageBundleRequest.cc
+	src/model/CreateStorageBundleResult.cc
+	src/model/DeleteExpressSyncRequest.cc
+	src/model/DeleteExpressSyncResult.cc
+	src/model/DeleteGatewayRequest.cc
+	src/model/DeleteGatewayResult.cc
+	src/model/DeleteGatewayBlockVolumesRequest.cc
+	src/model/DeleteGatewayBlockVolumesResult.cc
+	src/model/DeleteGatewayCacheDiskRequest.cc
+	src/model/DeleteGatewayCacheDiskResult.cc
+	src/model/DeleteGatewayFileSharesRequest.cc
+	src/model/DeleteGatewayFileSharesResult.cc
+	src/model/DeleteGatewayLoggingRequest.cc
+	src/model/DeleteGatewayLoggingResult.cc
+	src/model/DeleteGatewaySMBUserRequest.cc
+	src/model/DeleteGatewaySMBUserResult.cc
+	src/model/DeleteStorageBundleRequest.cc
+	src/model/DeleteStorageBundleResult.cc
+	src/model/DeployCacheDiskRequest.cc
+	src/model/DeployCacheDiskResult.cc
+	src/model/DeployGatewayRequest.cc
+	src/model/DeployGatewayResult.cc
+	src/model/DescribeAccountConfigRequest.cc
+	src/model/DescribeAccountConfigResult.cc
+	src/model/DescribeBlockVolumeSnapshotsRequest.cc
+	src/model/DescribeBlockVolumeSnapshotsResult.cc
+	src/model/DescribeDashboardRequest.cc
+	src/model/DescribeDashboardResult.cc
+	src/model/DescribeExpireCachesRequest.cc
+	src/model/DescribeExpireCachesResult.cc
+	src/model/DescribeExpressSyncSharesRequest.cc
+	src/model/DescribeExpressSyncSharesResult.cc
+	src/model/DescribeExpressSyncsRequest.cc
+	src/model/DescribeExpressSyncsResult.cc
+	src/model/DescribeGatewayRequest.cc
+	src/model/DescribeGatewayResult.cc
+	src/model/DescribeGatewayADInfoRequest.cc
+	src/model/DescribeGatewayADInfoResult.cc
+	src/model/DescribeGatewayActionsRequest.cc
+	src/model/DescribeGatewayActionsResult.cc
+	src/model/DescribeGatewayAuthInfoRequest.cc
+	src/model/DescribeGatewayAuthInfoResult.cc
+	src/model/DescribeGatewayBlockVolumesRequest.cc
+	src/model/DescribeGatewayBlockVolumesResult.cc
+	src/model/DescribeGatewayBucketCachesRequest.cc
+	src/model/DescribeGatewayBucketCachesResult.cc
+	src/model/DescribeGatewayCachesRequest.cc
+	src/model/DescribeGatewayCachesResult.cc
+	src/model/DescribeGatewayCapacityLimitRequest.cc
+	src/model/DescribeGatewayCapacityLimitResult.cc
+	src/model/DescribeGatewayCategoriesRequest.cc
+	src/model/DescribeGatewayCategoriesResult.cc
+	src/model/DescribeGatewayClassesRequest.cc
+	src/model/DescribeGatewayClassesResult.cc
+	src/model/DescribeGatewayCredentialRequest.cc
+	src/model/DescribeGatewayCredentialResult.cc
+	src/model/DescribeGatewayDNSRequest.cc
+	src/model/DescribeGatewayDNSResult.cc
+	src/model/DescribeGatewayFileSharesRequest.cc
+	src/model/DescribeGatewayFileSharesResult.cc
+	src/model/DescribeGatewayFileStatusRequest.cc
+	src/model/DescribeGatewayFileStatusResult.cc
+	src/model/DescribeGatewayImagesRequest.cc
+	src/model/DescribeGatewayImagesResult.cc
+	src/model/DescribeGatewayInfoRequest.cc
+	src/model/DescribeGatewayInfoResult.cc
+	src/model/DescribeGatewayLDAPInfoRequest.cc
+	src/model/DescribeGatewayLDAPInfoResult.cc
+	src/model/DescribeGatewayLocationsRequest.cc
+	src/model/DescribeGatewayLocationsResult.cc
+	src/model/DescribeGatewayLoggingRequest.cc
+	src/model/DescribeGatewayLoggingResult.cc
+	src/model/DescribeGatewayLogsRequest.cc
+	src/model/DescribeGatewayLogsResult.cc
+	src/model/DescribeGatewayModificationClassesRequest.cc
+	src/model/DescribeGatewayModificationClassesResult.cc
+	src/model/DescribeGatewaySMBUsersRequest.cc
+	src/model/DescribeGatewaySMBUsersResult.cc
+	src/model/DescribeGatewayStatisticsRequest.cc
+	src/model/DescribeGatewayStatisticsResult.cc
+	src/model/DescribeGatewayStockRequest.cc
+	src/model/DescribeGatewayStockResult.cc
+	src/model/DescribeGatewayTypesRequest.cc
+	src/model/DescribeGatewayTypesResult.cc
+	src/model/DescribeGatewaysRequest.cc
+	src/model/DescribeGatewaysResult.cc
+	src/model/DescribeGatewaysForCmsRequest.cc
+	src/model/DescribeGatewaysForCmsResult.cc
+	src/model/DescribeGatewaysTagsRequest.cc
+	src/model/DescribeGatewaysTagsResult.cc
+	src/model/DescribeKmsKeyRequest.cc
+	src/model/DescribeKmsKeyResult.cc
+	src/model/DescribeMqttConfigRequest.cc
+	src/model/DescribeMqttConfigResult.cc
+	src/model/DescribeOssBucketInfoRequest.cc
+	src/model/DescribeOssBucketInfoResult.cc
+	src/model/DescribeOssBucketsRequest.cc
+	src/model/DescribeOssBucketsResult.cc
+	src/model/DescribePayAsYouGoPriceRequest.cc
+	src/model/DescribePayAsYouGoPriceResult.cc
+	src/model/DescribeRegionsRequest.cc
+	src/model/DescribeRegionsResult.cc
+	src/model/DescribeSharesBucketInfoForExpressSyncRequest.cc
+	src/model/DescribeSharesBucketInfoForExpressSyncResult.cc
+	src/model/DescribeStorageBundleRequest.cc
+	src/model/DescribeStorageBundleResult.cc
+	src/model/DescribeStorageBundlesRequest.cc
+	src/model/DescribeStorageBundlesResult.cc
+	src/model/DescribeSubscriptionPriceRequest.cc
+	src/model/DescribeSubscriptionPriceResult.cc
+	src/model/DescribeTasksRequest.cc
+	src/model/DescribeTasksResult.cc
+	src/model/DescribeUserBusinessStatusRequest.cc
+	src/model/DescribeUserBusinessStatusResult.cc
+	src/model/DescribeVSwitchesRequest.cc
+	src/model/DescribeVSwitchesResult.cc
+	src/model/DescribeVpcsRequest.cc
+	src/model/DescribeVpcsResult.cc
+	src/model/DescribeZonesRequest.cc
+	src/model/DescribeZonesResult.cc
+	src/model/DisableGatewayLoggingRequest.cc
+	src/model/DisableGatewayLoggingResult.cc
+	src/model/EnableGatewayLoggingRequest.cc
+	src/model/EnableGatewayLoggingResult.cc
+	src/model/ExpandCacheDiskRequest.cc
+	src/model/ExpandCacheDiskResult.cc
+	src/model/ExpandGatewayNetworkBandwidthRequest.cc
+	src/model/ExpandGatewayNetworkBandwidthResult.cc
+	src/model/GenerateGatewayTokenRequest.cc
+	src/model/GenerateGatewayTokenResult.cc
+	src/model/GenerateMqttTokenRequest.cc
+	src/model/GenerateMqttTokenResult.cc
+	src/model/GenerateStsTokenRequest.cc
+	src/model/GenerateStsTokenResult.cc
+	src/model/ListTagResourcesRequest.cc
+	src/model/ListTagResourcesResult.cc
+	src/model/ModifyGatewayRequest.cc
+	src/model/ModifyGatewayResult.cc
+	src/model/ModifyGatewayBlockVolumeRequest.cc
+	src/model/ModifyGatewayBlockVolumeResult.cc
+	src/model/ModifyGatewayClassRequest.cc
+	src/model/ModifyGatewayClassResult.cc
+	src/model/ModifyGatewayFileShareRequest.cc
+	src/model/ModifyGatewayFileShareResult.cc
+	src/model/ModifyStorageBundleRequest.cc
+	src/model/ModifyStorageBundleResult.cc
+	src/model/OperateGatewayRequest.cc
+	src/model/OperateGatewayResult.cc
+	src/model/ReleaseServiceRequest.cc
+	src/model/ReleaseServiceResult.cc
+	src/model/RemoveSharesFromExpressSyncRequest.cc
+	src/model/RemoveSharesFromExpressSyncResult.cc
+	src/model/RemoveTagsFromGatewayRequest.cc
+	src/model/RemoveTagsFromGatewayResult.cc
+	src/model/ReportBlockVolumesRequest.cc
+	src/model/ReportBlockVolumesResult.cc
+	src/model/ReportFileSharesRequest.cc
+	src/model/ReportFileSharesResult.cc
+	src/model/ReportGatewayInfoRequest.cc
+	src/model/ReportGatewayInfoResult.cc
+	src/model/ReportGatewayUsageRequest.cc
+	src/model/ReportGatewayUsageResult.cc
+	src/model/ResetGatewayPasswordRequest.cc
+	src/model/ResetGatewayPasswordResult.cc
+	src/model/RestartFileSharesRequest.cc
+	src/model/RestartFileSharesResult.cc
+	src/model/SetGatewayADInfoRequest.cc
+	src/model/SetGatewayADInfoResult.cc
+	src/model/SetGatewayDNSRequest.cc
+	src/model/SetGatewayDNSResult.cc
+	src/model/SetGatewayLDAPInfoRequest.cc
+	src/model/SetGatewayLDAPInfoResult.cc
+	src/model/SwitchGatewayExpirationPolicyRequest.cc
+	src/model/SwitchGatewayExpirationPolicyResult.cc
+	src/model/SwitchToSubscriptionRequest.cc
+	src/model/SwitchToSubscriptionResult.cc
+	src/model/TagResourcesRequest.cc
+	src/model/TagResourcesResult.cc
+	src/model/UntagResourcesRequest.cc
+	src/model/UntagResourcesResult.cc
+	src/model/UpdateGatewayBlockVolumeRequest.cc
+	src/model/UpdateGatewayBlockVolumeResult.cc
+	src/model/UpdateGatewayFileShareRequest.cc
+	src/model/UpdateGatewayFileShareResult.cc
+	src/model/UpgradeGatewayRequest.cc
+	src/model/UpgradeGatewayResult.cc
+	src/model/UploadGatewayLogRequest.cc
+	src/model/UploadGatewayLogResult.cc
+	src/model/ValidateExpressSyncConfigRequest.cc
+	src/model/ValidateExpressSyncConfigResult.cc
+	src/model/ValidateGatewayNameRequest.cc
+	src/model/ValidateGatewayNameResult.cc )
+
+add_library(sgw ${LIB_TYPE}
+	${sgw_public_header}
+	${sgw_public_header_model}
+	${sgw_src})
+
+set_target_properties(sgw
+	PROPERTIES
+	LINKER_LANGUAGE CXX
+	ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+	OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}sgw
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(sgw
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_SGW_LIBRARY)
+endif()
+
+target_include_directories(sgw
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(sgw
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(sgw
+		jsoncpp)
+	target_include_directories(sgw
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(sgw
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(sgw
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(sgw
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(sgw
+		jsoncpp)
+endif()
+
+install(FILES ${sgw_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/sgw)
+install(FILES ${sgw_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/sgw/model)
+install(TARGETS sgw
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

sgw/include/alibabacloud/sgw/SgwClient.h

@@ -0,0 +1,966 @@
+/*
+ * 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_SGWCLIENT_H_
+#define ALIBABACLOUD_SGW_SGWCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "SgwExport.h"
+#include "model/ActivateAllInOneGatewayRequest.h"
+#include "model/ActivateAllInOneGatewayResult.h"
+#include "model/ActivateGatewayRequest.h"
+#include "model/ActivateGatewayResult.h"
+#include "model/AddSharesToExpressSyncRequest.h"
+#include "model/AddSharesToExpressSyncResult.h"
+#include "model/AddTagsToGatewayRequest.h"
+#include "model/AddTagsToGatewayResult.h"
+#include "model/CheckActivationKeyRequest.h"
+#include "model/CheckActivationKeyResult.h"
+#include "model/CheckBlockVolumeNameRequest.h"
+#include "model/CheckBlockVolumeNameResult.h"
+#include "model/CheckGatewayEssdSupportRequest.h"
+#include "model/CheckGatewayEssdSupportResult.h"
+#include "model/CheckMnsServiceRequest.h"
+#include "model/CheckMnsServiceResult.h"
+#include "model/CheckRoleRequest.h"
+#include "model/CheckRoleResult.h"
+#include "model/CheckSlrRoleRequest.h"
+#include "model/CheckSlrRoleResult.h"
+#include "model/CheckUpgradeVersionRequest.h"
+#include "model/CheckUpgradeVersionResult.h"
+#include "model/CreateCacheRequest.h"
+#include "model/CreateCacheResult.h"
+#include "model/CreateExpressSyncRequest.h"
+#include "model/CreateExpressSyncResult.h"
+#include "model/CreateGatewayRequest.h"
+#include "model/CreateGatewayResult.h"
+#include "model/CreateGatewayBlockVolumeRequest.h"
+#include "model/CreateGatewayBlockVolumeResult.h"
+#include "model/CreateGatewayCacheDiskRequest.h"
+#include "model/CreateGatewayCacheDiskResult.h"
+#include "model/CreateGatewayFileShareRequest.h"
+#include "model/CreateGatewayFileShareResult.h"
+#include "model/CreateGatewayLoggingRequest.h"
+#include "model/CreateGatewayLoggingResult.h"
+#include "model/CreateGatewaySMBUserRequest.h"
+#include "model/CreateGatewaySMBUserResult.h"
+#include "model/CreateStorageBundleRequest.h"
+#include "model/CreateStorageBundleResult.h"
+#include "model/DeleteExpressSyncRequest.h"
+#include "model/DeleteExpressSyncResult.h"
+#include "model/DeleteGatewayRequest.h"
+#include "model/DeleteGatewayResult.h"
+#include "model/DeleteGatewayBlockVolumesRequest.h"
+#include "model/DeleteGatewayBlockVolumesResult.h"
+#include "model/DeleteGatewayCacheDiskRequest.h"
+#include "model/DeleteGatewayCacheDiskResult.h"
+#include "model/DeleteGatewayFileSharesRequest.h"
+#include "model/DeleteGatewayFileSharesResult.h"
+#include "model/DeleteGatewayLoggingRequest.h"
+#include "model/DeleteGatewayLoggingResult.h"
+#include "model/DeleteGatewaySMBUserRequest.h"
+#include "model/DeleteGatewaySMBUserResult.h"
+#include "model/DeleteStorageBundleRequest.h"
+#include "model/DeleteStorageBundleResult.h"
+#include "model/DeployCacheDiskRequest.h"
+#include "model/DeployCacheDiskResult.h"
+#include "model/DeployGatewayRequest.h"
+#include "model/DeployGatewayResult.h"
+#include "model/DescribeAccountConfigRequest.h"
+#include "model/DescribeAccountConfigResult.h"
+#include "model/DescribeBlockVolumeSnapshotsRequest.h"
+#include "model/DescribeBlockVolumeSnapshotsResult.h"
+#include "model/DescribeDashboardRequest.h"
+#include "model/DescribeDashboardResult.h"
+#include "model/DescribeExpireCachesRequest.h"
+#include "model/DescribeExpireCachesResult.h"
+#include "model/DescribeExpressSyncSharesRequest.h"
+#include "model/DescribeExpressSyncSharesResult.h"
+#include "model/DescribeExpressSyncsRequest.h"
+#include "model/DescribeExpressSyncsResult.h"
+#include "model/DescribeGatewayRequest.h"
+#include "model/DescribeGatewayResult.h"
+#include "model/DescribeGatewayADInfoRequest.h"
+#include "model/DescribeGatewayADInfoResult.h"
+#include "model/DescribeGatewayActionsRequest.h"
+#include "model/DescribeGatewayActionsResult.h"
+#include "model/DescribeGatewayAuthInfoRequest.h"
+#include "model/DescribeGatewayAuthInfoResult.h"
+#include "model/DescribeGatewayBlockVolumesRequest.h"
+#include "model/DescribeGatewayBlockVolumesResult.h"
+#include "model/DescribeGatewayBucketCachesRequest.h"
+#include "model/DescribeGatewayBucketCachesResult.h"
+#include "model/DescribeGatewayCachesRequest.h"
+#include "model/DescribeGatewayCachesResult.h"
+#include "model/DescribeGatewayCapacityLimitRequest.h"
+#include "model/DescribeGatewayCapacityLimitResult.h"
+#include "model/DescribeGatewayCategoriesRequest.h"
+#include "model/DescribeGatewayCategoriesResult.h"
+#include "model/DescribeGatewayClassesRequest.h"
+#include "model/DescribeGatewayClassesResult.h"
+#include "model/DescribeGatewayCredentialRequest.h"
+#include "model/DescribeGatewayCredentialResult.h"
+#include "model/DescribeGatewayDNSRequest.h"
+#include "model/DescribeGatewayDNSResult.h"
+#include "model/DescribeGatewayFileSharesRequest.h"
+#include "model/DescribeGatewayFileSharesResult.h"
+#include "model/DescribeGatewayFileStatusRequest.h"
+#include "model/DescribeGatewayFileStatusResult.h"
+#include "model/DescribeGatewayImagesRequest.h"
+#include "model/DescribeGatewayImagesResult.h"
+#include "model/DescribeGatewayInfoRequest.h"
+#include "model/DescribeGatewayInfoResult.h"
+#include "model/DescribeGatewayLDAPInfoRequest.h"
+#include "model/DescribeGatewayLDAPInfoResult.h"
+#include "model/DescribeGatewayLocationsRequest.h"
+#include "model/DescribeGatewayLocationsResult.h"
+#include "model/DescribeGatewayLoggingRequest.h"
+#include "model/DescribeGatewayLoggingResult.h"
+#include "model/DescribeGatewayLogsRequest.h"
+#include "model/DescribeGatewayLogsResult.h"
+#include "model/DescribeGatewayModificationClassesRequest.h"
+#include "model/DescribeGatewayModificationClassesResult.h"
+#include "model/DescribeGatewaySMBUsersRequest.h"
+#include "model/DescribeGatewaySMBUsersResult.h"
+#include "model/DescribeGatewayStatisticsRequest.h"
+#include "model/DescribeGatewayStatisticsResult.h"
+#include "model/DescribeGatewayStockRequest.h"
+#include "model/DescribeGatewayStockResult.h"
+#include "model/DescribeGatewayTypesRequest.h"
+#include "model/DescribeGatewayTypesResult.h"
+#include "model/DescribeGatewaysRequest.h"
+#include "model/DescribeGatewaysResult.h"
+#include "model/DescribeGatewaysForCmsRequest.h"
+#include "model/DescribeGatewaysForCmsResult.h"
+#include "model/DescribeGatewaysTagsRequest.h"
+#include "model/DescribeGatewaysTagsResult.h"
+#include "model/DescribeKmsKeyRequest.h"
+#include "model/DescribeKmsKeyResult.h"
+#include "model/DescribeMqttConfigRequest.h"
+#include "model/DescribeMqttConfigResult.h"
+#include "model/DescribeOssBucketInfoRequest.h"
+#include "model/DescribeOssBucketInfoResult.h"
+#include "model/DescribeOssBucketsRequest.h"
+#include "model/DescribeOssBucketsResult.h"
+#include "model/DescribePayAsYouGoPriceRequest.h"
+#include "model/DescribePayAsYouGoPriceResult.h"
+#include "model/DescribeRegionsRequest.h"
+#include "model/DescribeRegionsResult.h"
+#include "model/DescribeSharesBucketInfoForExpressSyncRequest.h"
+#include "model/DescribeSharesBucketInfoForExpressSyncResult.h"
+#include "model/DescribeStorageBundleRequest.h"
+#include "model/DescribeStorageBundleResult.h"
+#include "model/DescribeStorageBundlesRequest.h"
+#include "model/DescribeStorageBundlesResult.h"
+#include "model/DescribeSubscriptionPriceRequest.h"
+#include "model/DescribeSubscriptionPriceResult.h"
+#include "model/DescribeTasksRequest.h"
+#include "model/DescribeTasksResult.h"
+#include "model/DescribeUserBusinessStatusRequest.h"
+#include "model/DescribeUserBusinessStatusResult.h"
+#include "model/DescribeVSwitchesRequest.h"
+#include "model/DescribeVSwitchesResult.h"
+#include "model/DescribeVpcsRequest.h"
+#include "model/DescribeVpcsResult.h"
+#include "model/DescribeZonesRequest.h"
+#include "model/DescribeZonesResult.h"
+#include "model/DisableGatewayLoggingRequest.h"
+#include "model/DisableGatewayLoggingResult.h"
+#include "model/EnableGatewayLoggingRequest.h"
+#include "model/EnableGatewayLoggingResult.h"
+#include "model/ExpandCacheDiskRequest.h"
+#include "model/ExpandCacheDiskResult.h"
+#include "model/ExpandGatewayNetworkBandwidthRequest.h"
+#include "model/ExpandGatewayNetworkBandwidthResult.h"
+#include "model/GenerateGatewayTokenRequest.h"
+#include "model/GenerateGatewayTokenResult.h"
+#include "model/GenerateMqttTokenRequest.h"
+#include "model/GenerateMqttTokenResult.h"
+#include "model/GenerateStsTokenRequest.h"
+#include "model/GenerateStsTokenResult.h"
+#include "model/ListTagResourcesRequest.h"
+#include "model/ListTagResourcesResult.h"
+#include "model/ModifyGatewayRequest.h"
+#include "model/ModifyGatewayResult.h"
+#include "model/ModifyGatewayBlockVolumeRequest.h"
+#include "model/ModifyGatewayBlockVolumeResult.h"
+#include "model/ModifyGatewayClassRequest.h"
+#include "model/ModifyGatewayClassResult.h"
+#include "model/ModifyGatewayFileShareRequest.h"
+#include "model/ModifyGatewayFileShareResult.h"
+#include "model/ModifyStorageBundleRequest.h"
+#include "model/ModifyStorageBundleResult.h"
+#include "model/OperateGatewayRequest.h"
+#include "model/OperateGatewayResult.h"
+#include "model/ReleaseServiceRequest.h"
+#include "model/ReleaseServiceResult.h"
+#include "model/RemoveSharesFromExpressSyncRequest.h"
+#include "model/RemoveSharesFromExpressSyncResult.h"
+#include "model/RemoveTagsFromGatewayRequest.h"
+#include "model/RemoveTagsFromGatewayResult.h"
+#include "model/ReportBlockVolumesRequest.h"
+#include "model/ReportBlockVolumesResult.h"
+#include "model/ReportFileSharesRequest.h"
+#include "model/ReportFileSharesResult.h"
+#include "model/ReportGatewayInfoRequest.h"
+#include "model/ReportGatewayInfoResult.h"
+#include "model/ReportGatewayUsageRequest.h"
+#include "model/ReportGatewayUsageResult.h"
+#include "model/ResetGatewayPasswordRequest.h"
+#include "model/ResetGatewayPasswordResult.h"
+#include "model/RestartFileSharesRequest.h"
+#include "model/RestartFileSharesResult.h"
+#include "model/SetGatewayADInfoRequest.h"
+#include "model/SetGatewayADInfoResult.h"
+#include "model/SetGatewayDNSRequest.h"
+#include "model/SetGatewayDNSResult.h"
+#include "model/SetGatewayLDAPInfoRequest.h"
+#include "model/SetGatewayLDAPInfoResult.h"
+#include "model/SwitchGatewayExpirationPolicyRequest.h"
+#include "model/SwitchGatewayExpirationPolicyResult.h"
+#include "model/SwitchToSubscriptionRequest.h"
+#include "model/SwitchToSubscriptionResult.h"
+#include "model/TagResourcesRequest.h"
+#include "model/TagResourcesResult.h"
+#include "model/UntagResourcesRequest.h"
+#include "model/UntagResourcesResult.h"
+#include "model/UpdateGatewayBlockVolumeRequest.h"
+#include "model/UpdateGatewayBlockVolumeResult.h"
+#include "model/UpdateGatewayFileShareRequest.h"
+#include "model/UpdateGatewayFileShareResult.h"
+#include "model/UpgradeGatewayRequest.h"
+#include "model/UpgradeGatewayResult.h"
+#include "model/UploadGatewayLogRequest.h"
+#include "model/UploadGatewayLogResult.h"
+#include "model/ValidateExpressSyncConfigRequest.h"
+#include "model/ValidateExpressSyncConfigResult.h"
+#include "model/ValidateGatewayNameRequest.h"
+#include "model/ValidateGatewayNameResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Sgw
+	{
+		class ALIBABACLOUD_SGW_EXPORT SgwClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::ActivateAllInOneGatewayResult> ActivateAllInOneGatewayOutcome;
+			typedef std::future<ActivateAllInOneGatewayOutcome> ActivateAllInOneGatewayOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::ActivateAllInOneGatewayRequest&, const ActivateAllInOneGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ActivateAllInOneGatewayAsyncHandler;
+			typedef Outcome<Error, Model::ActivateGatewayResult> ActivateGatewayOutcome;
+			typedef std::future<ActivateGatewayOutcome> ActivateGatewayOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::ActivateGatewayRequest&, const ActivateGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ActivateGatewayAsyncHandler;
+			typedef Outcome<Error, Model::AddSharesToExpressSyncResult> AddSharesToExpressSyncOutcome;
+			typedef std::future<AddSharesToExpressSyncOutcome> AddSharesToExpressSyncOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::AddSharesToExpressSyncRequest&, const AddSharesToExpressSyncOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddSharesToExpressSyncAsyncHandler;
+			typedef Outcome<Error, Model::AddTagsToGatewayResult> AddTagsToGatewayOutcome;
+			typedef std::future<AddTagsToGatewayOutcome> AddTagsToGatewayOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::AddTagsToGatewayRequest&, const AddTagsToGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddTagsToGatewayAsyncHandler;
+			typedef Outcome<Error, Model::CheckActivationKeyResult> CheckActivationKeyOutcome;
+			typedef std::future<CheckActivationKeyOutcome> CheckActivationKeyOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::CheckActivationKeyRequest&, const CheckActivationKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckActivationKeyAsyncHandler;
+			typedef Outcome<Error, Model::CheckBlockVolumeNameResult> CheckBlockVolumeNameOutcome;
+			typedef std::future<CheckBlockVolumeNameOutcome> CheckBlockVolumeNameOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::CheckBlockVolumeNameRequest&, const CheckBlockVolumeNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckBlockVolumeNameAsyncHandler;
+			typedef Outcome<Error, Model::CheckGatewayEssdSupportResult> CheckGatewayEssdSupportOutcome;
+			typedef std::future<CheckGatewayEssdSupportOutcome> CheckGatewayEssdSupportOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::CheckGatewayEssdSupportRequest&, const CheckGatewayEssdSupportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckGatewayEssdSupportAsyncHandler;
+			typedef Outcome<Error, Model::CheckMnsServiceResult> CheckMnsServiceOutcome;
+			typedef std::future<CheckMnsServiceOutcome> CheckMnsServiceOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::CheckMnsServiceRequest&, const CheckMnsServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckMnsServiceAsyncHandler;
+			typedef Outcome<Error, Model::CheckRoleResult> CheckRoleOutcome;
+			typedef std::future<CheckRoleOutcome> CheckRoleOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::CheckRoleRequest&, const CheckRoleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckRoleAsyncHandler;
+			typedef Outcome<Error, Model::CheckSlrRoleResult> CheckSlrRoleOutcome;
+			typedef std::future<CheckSlrRoleOutcome> CheckSlrRoleOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::CheckSlrRoleRequest&, const CheckSlrRoleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckSlrRoleAsyncHandler;
+			typedef Outcome<Error, Model::CheckUpgradeVersionResult> CheckUpgradeVersionOutcome;
+			typedef std::future<CheckUpgradeVersionOutcome> CheckUpgradeVersionOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::CheckUpgradeVersionRequest&, const CheckUpgradeVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckUpgradeVersionAsyncHandler;
+			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::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;
+			typedef Outcome<Error, Model::CreateGatewayResult> CreateGatewayOutcome;
+			typedef std::future<CreateGatewayOutcome> CreateGatewayOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::CreateGatewayRequest&, const CreateGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGatewayAsyncHandler;
+			typedef Outcome<Error, Model::CreateGatewayBlockVolumeResult> CreateGatewayBlockVolumeOutcome;
+			typedef std::future<CreateGatewayBlockVolumeOutcome> CreateGatewayBlockVolumeOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::CreateGatewayBlockVolumeRequest&, const CreateGatewayBlockVolumeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGatewayBlockVolumeAsyncHandler;
+			typedef Outcome<Error, Model::CreateGatewayCacheDiskResult> CreateGatewayCacheDiskOutcome;
+			typedef std::future<CreateGatewayCacheDiskOutcome> CreateGatewayCacheDiskOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::CreateGatewayCacheDiskRequest&, const CreateGatewayCacheDiskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGatewayCacheDiskAsyncHandler;
+			typedef Outcome<Error, Model::CreateGatewayFileShareResult> CreateGatewayFileShareOutcome;
+			typedef std::future<CreateGatewayFileShareOutcome> CreateGatewayFileShareOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::CreateGatewayFileShareRequest&, const CreateGatewayFileShareOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGatewayFileShareAsyncHandler;
+			typedef Outcome<Error, Model::CreateGatewayLoggingResult> CreateGatewayLoggingOutcome;
+			typedef std::future<CreateGatewayLoggingOutcome> CreateGatewayLoggingOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::CreateGatewayLoggingRequest&, const CreateGatewayLoggingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGatewayLoggingAsyncHandler;
+			typedef Outcome<Error, Model::CreateGatewaySMBUserResult> CreateGatewaySMBUserOutcome;
+			typedef std::future<CreateGatewaySMBUserOutcome> CreateGatewaySMBUserOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::CreateGatewaySMBUserRequest&, const CreateGatewaySMBUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGatewaySMBUserAsyncHandler;
+			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::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;
+			typedef Outcome<Error, Model::DeleteGatewayResult> DeleteGatewayOutcome;
+			typedef std::future<DeleteGatewayOutcome> DeleteGatewayOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DeleteGatewayRequest&, const DeleteGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayAsyncHandler;
+			typedef Outcome<Error, Model::DeleteGatewayBlockVolumesResult> DeleteGatewayBlockVolumesOutcome;
+			typedef std::future<DeleteGatewayBlockVolumesOutcome> DeleteGatewayBlockVolumesOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DeleteGatewayBlockVolumesRequest&, const DeleteGatewayBlockVolumesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayBlockVolumesAsyncHandler;
+			typedef Outcome<Error, Model::DeleteGatewayCacheDiskResult> DeleteGatewayCacheDiskOutcome;
+			typedef std::future<DeleteGatewayCacheDiskOutcome> DeleteGatewayCacheDiskOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DeleteGatewayCacheDiskRequest&, const DeleteGatewayCacheDiskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayCacheDiskAsyncHandler;
+			typedef Outcome<Error, Model::DeleteGatewayFileSharesResult> DeleteGatewayFileSharesOutcome;
+			typedef std::future<DeleteGatewayFileSharesOutcome> DeleteGatewayFileSharesOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DeleteGatewayFileSharesRequest&, const DeleteGatewayFileSharesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayFileSharesAsyncHandler;
+			typedef Outcome<Error, Model::DeleteGatewayLoggingResult> DeleteGatewayLoggingOutcome;
+			typedef std::future<DeleteGatewayLoggingOutcome> DeleteGatewayLoggingOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DeleteGatewayLoggingRequest&, const DeleteGatewayLoggingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayLoggingAsyncHandler;
+			typedef Outcome<Error, Model::DeleteGatewaySMBUserResult> DeleteGatewaySMBUserOutcome;
+			typedef std::future<DeleteGatewaySMBUserOutcome> DeleteGatewaySMBUserOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DeleteGatewaySMBUserRequest&, const DeleteGatewaySMBUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewaySMBUserAsyncHandler;
+			typedef Outcome<Error, Model::DeleteStorageBundleResult> DeleteStorageBundleOutcome;
+			typedef std::future<DeleteStorageBundleOutcome> DeleteStorageBundleOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DeleteStorageBundleRequest&, const DeleteStorageBundleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteStorageBundleAsyncHandler;
+			typedef Outcome<Error, Model::DeployCacheDiskResult> DeployCacheDiskOutcome;
+			typedef std::future<DeployCacheDiskOutcome> DeployCacheDiskOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DeployCacheDiskRequest&, const DeployCacheDiskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeployCacheDiskAsyncHandler;
+			typedef Outcome<Error, Model::DeployGatewayResult> DeployGatewayOutcome;
+			typedef std::future<DeployGatewayOutcome> DeployGatewayOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DeployGatewayRequest&, const DeployGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeployGatewayAsyncHandler;
+			typedef Outcome<Error, Model::DescribeAccountConfigResult> DescribeAccountConfigOutcome;
+			typedef std::future<DescribeAccountConfigOutcome> DescribeAccountConfigOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeAccountConfigRequest&, const DescribeAccountConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccountConfigAsyncHandler;
+			typedef Outcome<Error, Model::DescribeBlockVolumeSnapshotsResult> DescribeBlockVolumeSnapshotsOutcome;
+			typedef std::future<DescribeBlockVolumeSnapshotsOutcome> DescribeBlockVolumeSnapshotsOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeBlockVolumeSnapshotsRequest&, const DescribeBlockVolumeSnapshotsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBlockVolumeSnapshotsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDashboardResult> DescribeDashboardOutcome;
+			typedef std::future<DescribeDashboardOutcome> DescribeDashboardOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeDashboardRequest&, const DescribeDashboardOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDashboardAsyncHandler;
+			typedef Outcome<Error, Model::DescribeExpireCachesResult> DescribeExpireCachesOutcome;
+			typedef std::future<DescribeExpireCachesOutcome> DescribeExpireCachesOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeExpireCachesRequest&, const DescribeExpireCachesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeExpireCachesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeExpressSyncSharesResult> DescribeExpressSyncSharesOutcome;
+			typedef std::future<DescribeExpressSyncSharesOutcome> DescribeExpressSyncSharesOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeExpressSyncSharesRequest&, const DescribeExpressSyncSharesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeExpressSyncSharesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeExpressSyncsResult> DescribeExpressSyncsOutcome;
+			typedef std::future<DescribeExpressSyncsOutcome> DescribeExpressSyncsOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeExpressSyncsRequest&, const DescribeExpressSyncsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeExpressSyncsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayResult> DescribeGatewayOutcome;
+			typedef std::future<DescribeGatewayOutcome> DescribeGatewayOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayRequest&, const DescribeGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayADInfoResult> DescribeGatewayADInfoOutcome;
+			typedef std::future<DescribeGatewayADInfoOutcome> DescribeGatewayADInfoOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayADInfoRequest&, const DescribeGatewayADInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayADInfoAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayActionsResult> DescribeGatewayActionsOutcome;
+			typedef std::future<DescribeGatewayActionsOutcome> DescribeGatewayActionsOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayActionsRequest&, const DescribeGatewayActionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayActionsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayAuthInfoResult> DescribeGatewayAuthInfoOutcome;
+			typedef std::future<DescribeGatewayAuthInfoOutcome> DescribeGatewayAuthInfoOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayAuthInfoRequest&, const DescribeGatewayAuthInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayAuthInfoAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayBlockVolumesResult> DescribeGatewayBlockVolumesOutcome;
+			typedef std::future<DescribeGatewayBlockVolumesOutcome> DescribeGatewayBlockVolumesOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayBlockVolumesRequest&, const DescribeGatewayBlockVolumesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayBlockVolumesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayBucketCachesResult> DescribeGatewayBucketCachesOutcome;
+			typedef std::future<DescribeGatewayBucketCachesOutcome> DescribeGatewayBucketCachesOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayBucketCachesRequest&, const DescribeGatewayBucketCachesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayBucketCachesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayCachesResult> DescribeGatewayCachesOutcome;
+			typedef std::future<DescribeGatewayCachesOutcome> DescribeGatewayCachesOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayCachesRequest&, const DescribeGatewayCachesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayCachesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayCapacityLimitResult> DescribeGatewayCapacityLimitOutcome;
+			typedef std::future<DescribeGatewayCapacityLimitOutcome> DescribeGatewayCapacityLimitOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayCapacityLimitRequest&, const DescribeGatewayCapacityLimitOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayCapacityLimitAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayCategoriesResult> DescribeGatewayCategoriesOutcome;
+			typedef std::future<DescribeGatewayCategoriesOutcome> DescribeGatewayCategoriesOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayCategoriesRequest&, const DescribeGatewayCategoriesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayCategoriesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayClassesResult> DescribeGatewayClassesOutcome;
+			typedef std::future<DescribeGatewayClassesOutcome> DescribeGatewayClassesOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayClassesRequest&, const DescribeGatewayClassesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayClassesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayCredentialResult> DescribeGatewayCredentialOutcome;
+			typedef std::future<DescribeGatewayCredentialOutcome> DescribeGatewayCredentialOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayCredentialRequest&, const DescribeGatewayCredentialOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayCredentialAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayDNSResult> DescribeGatewayDNSOutcome;
+			typedef std::future<DescribeGatewayDNSOutcome> DescribeGatewayDNSOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayDNSRequest&, const DescribeGatewayDNSOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayDNSAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayFileSharesResult> DescribeGatewayFileSharesOutcome;
+			typedef std::future<DescribeGatewayFileSharesOutcome> DescribeGatewayFileSharesOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayFileSharesRequest&, const DescribeGatewayFileSharesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayFileSharesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayFileStatusResult> DescribeGatewayFileStatusOutcome;
+			typedef std::future<DescribeGatewayFileStatusOutcome> DescribeGatewayFileStatusOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayFileStatusRequest&, const DescribeGatewayFileStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayFileStatusAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayImagesResult> DescribeGatewayImagesOutcome;
+			typedef std::future<DescribeGatewayImagesOutcome> DescribeGatewayImagesOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayImagesRequest&, const DescribeGatewayImagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayImagesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayInfoResult> DescribeGatewayInfoOutcome;
+			typedef std::future<DescribeGatewayInfoOutcome> DescribeGatewayInfoOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayInfoRequest&, const DescribeGatewayInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayInfoAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayLDAPInfoResult> DescribeGatewayLDAPInfoOutcome;
+			typedef std::future<DescribeGatewayLDAPInfoOutcome> DescribeGatewayLDAPInfoOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayLDAPInfoRequest&, const DescribeGatewayLDAPInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayLDAPInfoAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayLocationsResult> DescribeGatewayLocationsOutcome;
+			typedef std::future<DescribeGatewayLocationsOutcome> DescribeGatewayLocationsOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayLocationsRequest&, const DescribeGatewayLocationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayLocationsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayLoggingResult> DescribeGatewayLoggingOutcome;
+			typedef std::future<DescribeGatewayLoggingOutcome> DescribeGatewayLoggingOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayLoggingRequest&, const DescribeGatewayLoggingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayLoggingAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayLogsResult> DescribeGatewayLogsOutcome;
+			typedef std::future<DescribeGatewayLogsOutcome> DescribeGatewayLogsOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayLogsRequest&, const DescribeGatewayLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayLogsAsyncHandler;
+			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::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;
+			typedef Outcome<Error, Model::DescribeGatewayStatisticsResult> DescribeGatewayStatisticsOutcome;
+			typedef std::future<DescribeGatewayStatisticsOutcome> DescribeGatewayStatisticsOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayStatisticsRequest&, const DescribeGatewayStatisticsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayStatisticsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayStockResult> DescribeGatewayStockOutcome;
+			typedef std::future<DescribeGatewayStockOutcome> DescribeGatewayStockOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayStockRequest&, const DescribeGatewayStockOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayStockAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewayTypesResult> DescribeGatewayTypesOutcome;
+			typedef std::future<DescribeGatewayTypesOutcome> DescribeGatewayTypesOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewayTypesRequest&, const DescribeGatewayTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayTypesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewaysResult> DescribeGatewaysOutcome;
+			typedef std::future<DescribeGatewaysOutcome> DescribeGatewaysOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewaysRequest&, const DescribeGatewaysOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewaysAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewaysForCmsResult> DescribeGatewaysForCmsOutcome;
+			typedef std::future<DescribeGatewaysForCmsOutcome> DescribeGatewaysForCmsOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewaysForCmsRequest&, const DescribeGatewaysForCmsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewaysForCmsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGatewaysTagsResult> DescribeGatewaysTagsOutcome;
+			typedef std::future<DescribeGatewaysTagsOutcome> DescribeGatewaysTagsOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeGatewaysTagsRequest&, const DescribeGatewaysTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewaysTagsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeKmsKeyResult> DescribeKmsKeyOutcome;
+			typedef std::future<DescribeKmsKeyOutcome> DescribeKmsKeyOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeKmsKeyRequest&, const DescribeKmsKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeKmsKeyAsyncHandler;
+			typedef Outcome<Error, Model::DescribeMqttConfigResult> DescribeMqttConfigOutcome;
+			typedef std::future<DescribeMqttConfigOutcome> DescribeMqttConfigOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeMqttConfigRequest&, const DescribeMqttConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMqttConfigAsyncHandler;
+			typedef Outcome<Error, Model::DescribeOssBucketInfoResult> DescribeOssBucketInfoOutcome;
+			typedef std::future<DescribeOssBucketInfoOutcome> DescribeOssBucketInfoOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeOssBucketInfoRequest&, const DescribeOssBucketInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeOssBucketInfoAsyncHandler;
+			typedef Outcome<Error, Model::DescribeOssBucketsResult> DescribeOssBucketsOutcome;
+			typedef std::future<DescribeOssBucketsOutcome> DescribeOssBucketsOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeOssBucketsRequest&, const DescribeOssBucketsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeOssBucketsAsyncHandler;
+			typedef Outcome<Error, Model::DescribePayAsYouGoPriceResult> DescribePayAsYouGoPriceOutcome;
+			typedef std::future<DescribePayAsYouGoPriceOutcome> DescribePayAsYouGoPriceOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribePayAsYouGoPriceRequest&, const DescribePayAsYouGoPriceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePayAsYouGoPriceAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
+			typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeSharesBucketInfoForExpressSyncResult> DescribeSharesBucketInfoForExpressSyncOutcome;
+			typedef std::future<DescribeSharesBucketInfoForExpressSyncOutcome> DescribeSharesBucketInfoForExpressSyncOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeSharesBucketInfoForExpressSyncRequest&, const DescribeSharesBucketInfoForExpressSyncOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSharesBucketInfoForExpressSyncAsyncHandler;
+			typedef Outcome<Error, Model::DescribeStorageBundleResult> DescribeStorageBundleOutcome;
+			typedef std::future<DescribeStorageBundleOutcome> DescribeStorageBundleOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeStorageBundleRequest&, const DescribeStorageBundleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeStorageBundleAsyncHandler;
+			typedef Outcome<Error, Model::DescribeStorageBundlesResult> DescribeStorageBundlesOutcome;
+			typedef std::future<DescribeStorageBundlesOutcome> DescribeStorageBundlesOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeStorageBundlesRequest&, const DescribeStorageBundlesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeStorageBundlesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeSubscriptionPriceResult> DescribeSubscriptionPriceOutcome;
+			typedef std::future<DescribeSubscriptionPriceOutcome> DescribeSubscriptionPriceOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeSubscriptionPriceRequest&, const DescribeSubscriptionPriceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSubscriptionPriceAsyncHandler;
+			typedef Outcome<Error, Model::DescribeTasksResult> DescribeTasksOutcome;
+			typedef std::future<DescribeTasksOutcome> DescribeTasksOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeTasksRequest&, const DescribeTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTasksAsyncHandler;
+			typedef Outcome<Error, Model::DescribeUserBusinessStatusResult> DescribeUserBusinessStatusOutcome;
+			typedef std::future<DescribeUserBusinessStatusOutcome> DescribeUserBusinessStatusOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeUserBusinessStatusRequest&, const DescribeUserBusinessStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeUserBusinessStatusAsyncHandler;
+			typedef Outcome<Error, Model::DescribeVSwitchesResult> DescribeVSwitchesOutcome;
+			typedef std::future<DescribeVSwitchesOutcome> DescribeVSwitchesOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeVSwitchesRequest&, const DescribeVSwitchesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVSwitchesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeVpcsResult> DescribeVpcsOutcome;
+			typedef std::future<DescribeVpcsOutcome> DescribeVpcsOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeVpcsRequest&, const DescribeVpcsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVpcsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeZonesResult> DescribeZonesOutcome;
+			typedef std::future<DescribeZonesOutcome> DescribeZonesOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::DescribeZonesRequest&, const DescribeZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeZonesAsyncHandler;
+			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::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;
+			typedef Outcome<Error, Model::ExpandCacheDiskResult> ExpandCacheDiskOutcome;
+			typedef std::future<ExpandCacheDiskOutcome> ExpandCacheDiskOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::ExpandCacheDiskRequest&, const ExpandCacheDiskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExpandCacheDiskAsyncHandler;
+			typedef Outcome<Error, Model::ExpandGatewayNetworkBandwidthResult> ExpandGatewayNetworkBandwidthOutcome;
+			typedef std::future<ExpandGatewayNetworkBandwidthOutcome> ExpandGatewayNetworkBandwidthOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::ExpandGatewayNetworkBandwidthRequest&, const ExpandGatewayNetworkBandwidthOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExpandGatewayNetworkBandwidthAsyncHandler;
+			typedef Outcome<Error, Model::GenerateGatewayTokenResult> GenerateGatewayTokenOutcome;
+			typedef std::future<GenerateGatewayTokenOutcome> GenerateGatewayTokenOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::GenerateGatewayTokenRequest&, const GenerateGatewayTokenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateGatewayTokenAsyncHandler;
+			typedef Outcome<Error, Model::GenerateMqttTokenResult> GenerateMqttTokenOutcome;
+			typedef std::future<GenerateMqttTokenOutcome> GenerateMqttTokenOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::GenerateMqttTokenRequest&, const GenerateMqttTokenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateMqttTokenAsyncHandler;
+			typedef Outcome<Error, Model::GenerateStsTokenResult> GenerateStsTokenOutcome;
+			typedef std::future<GenerateStsTokenOutcome> GenerateStsTokenOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::GenerateStsTokenRequest&, const GenerateStsTokenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateStsTokenAsyncHandler;
+			typedef Outcome<Error, Model::ListTagResourcesResult> ListTagResourcesOutcome;
+			typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
+			typedef Outcome<Error, Model::ModifyGatewayResult> ModifyGatewayOutcome;
+			typedef std::future<ModifyGatewayOutcome> ModifyGatewayOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::ModifyGatewayRequest&, const ModifyGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyGatewayAsyncHandler;
+			typedef Outcome<Error, Model::ModifyGatewayBlockVolumeResult> ModifyGatewayBlockVolumeOutcome;
+			typedef std::future<ModifyGatewayBlockVolumeOutcome> ModifyGatewayBlockVolumeOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::ModifyGatewayBlockVolumeRequest&, const ModifyGatewayBlockVolumeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyGatewayBlockVolumeAsyncHandler;
+			typedef Outcome<Error, Model::ModifyGatewayClassResult> ModifyGatewayClassOutcome;
+			typedef std::future<ModifyGatewayClassOutcome> ModifyGatewayClassOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::ModifyGatewayClassRequest&, const ModifyGatewayClassOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyGatewayClassAsyncHandler;
+			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::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::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;
+			typedef Outcome<Error, Model::ReleaseServiceResult> ReleaseServiceOutcome;
+			typedef std::future<ReleaseServiceOutcome> ReleaseServiceOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::ReleaseServiceRequest&, const ReleaseServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReleaseServiceAsyncHandler;
+			typedef Outcome<Error, Model::RemoveSharesFromExpressSyncResult> RemoveSharesFromExpressSyncOutcome;
+			typedef std::future<RemoveSharesFromExpressSyncOutcome> RemoveSharesFromExpressSyncOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::RemoveSharesFromExpressSyncRequest&, const RemoveSharesFromExpressSyncOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveSharesFromExpressSyncAsyncHandler;
+			typedef Outcome<Error, Model::RemoveTagsFromGatewayResult> RemoveTagsFromGatewayOutcome;
+			typedef std::future<RemoveTagsFromGatewayOutcome> RemoveTagsFromGatewayOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::RemoveTagsFromGatewayRequest&, const RemoveTagsFromGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveTagsFromGatewayAsyncHandler;
+			typedef Outcome<Error, Model::ReportBlockVolumesResult> ReportBlockVolumesOutcome;
+			typedef std::future<ReportBlockVolumesOutcome> ReportBlockVolumesOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::ReportBlockVolumesRequest&, const ReportBlockVolumesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReportBlockVolumesAsyncHandler;
+			typedef Outcome<Error, Model::ReportFileSharesResult> ReportFileSharesOutcome;
+			typedef std::future<ReportFileSharesOutcome> ReportFileSharesOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::ReportFileSharesRequest&, const ReportFileSharesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReportFileSharesAsyncHandler;
+			typedef Outcome<Error, Model::ReportGatewayInfoResult> ReportGatewayInfoOutcome;
+			typedef std::future<ReportGatewayInfoOutcome> ReportGatewayInfoOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::ReportGatewayInfoRequest&, const ReportGatewayInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReportGatewayInfoAsyncHandler;
+			typedef Outcome<Error, Model::ReportGatewayUsageResult> ReportGatewayUsageOutcome;
+			typedef std::future<ReportGatewayUsageOutcome> ReportGatewayUsageOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::ReportGatewayUsageRequest&, const ReportGatewayUsageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReportGatewayUsageAsyncHandler;
+			typedef Outcome<Error, Model::ResetGatewayPasswordResult> ResetGatewayPasswordOutcome;
+			typedef std::future<ResetGatewayPasswordOutcome> ResetGatewayPasswordOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::ResetGatewayPasswordRequest&, const ResetGatewayPasswordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResetGatewayPasswordAsyncHandler;
+			typedef Outcome<Error, Model::RestartFileSharesResult> RestartFileSharesOutcome;
+			typedef std::future<RestartFileSharesOutcome> RestartFileSharesOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::RestartFileSharesRequest&, const RestartFileSharesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestartFileSharesAsyncHandler;
+			typedef Outcome<Error, Model::SetGatewayADInfoResult> SetGatewayADInfoOutcome;
+			typedef std::future<SetGatewayADInfoOutcome> SetGatewayADInfoOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::SetGatewayADInfoRequest&, const SetGatewayADInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetGatewayADInfoAsyncHandler;
+			typedef Outcome<Error, Model::SetGatewayDNSResult> SetGatewayDNSOutcome;
+			typedef std::future<SetGatewayDNSOutcome> SetGatewayDNSOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::SetGatewayDNSRequest&, const SetGatewayDNSOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetGatewayDNSAsyncHandler;
+			typedef Outcome<Error, Model::SetGatewayLDAPInfoResult> SetGatewayLDAPInfoOutcome;
+			typedef std::future<SetGatewayLDAPInfoOutcome> SetGatewayLDAPInfoOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::SetGatewayLDAPInfoRequest&, const SetGatewayLDAPInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetGatewayLDAPInfoAsyncHandler;
+			typedef Outcome<Error, Model::SwitchGatewayExpirationPolicyResult> SwitchGatewayExpirationPolicyOutcome;
+			typedef std::future<SwitchGatewayExpirationPolicyOutcome> SwitchGatewayExpirationPolicyOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::SwitchGatewayExpirationPolicyRequest&, const SwitchGatewayExpirationPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SwitchGatewayExpirationPolicyAsyncHandler;
+			typedef Outcome<Error, Model::SwitchToSubscriptionResult> SwitchToSubscriptionOutcome;
+			typedef std::future<SwitchToSubscriptionOutcome> SwitchToSubscriptionOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::SwitchToSubscriptionRequest&, const SwitchToSubscriptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SwitchToSubscriptionAsyncHandler;
+			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::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;
+			typedef Outcome<Error, Model::UpdateGatewayBlockVolumeResult> UpdateGatewayBlockVolumeOutcome;
+			typedef std::future<UpdateGatewayBlockVolumeOutcome> UpdateGatewayBlockVolumeOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::UpdateGatewayBlockVolumeRequest&, const UpdateGatewayBlockVolumeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayBlockVolumeAsyncHandler;
+			typedef Outcome<Error, Model::UpdateGatewayFileShareResult> UpdateGatewayFileShareOutcome;
+			typedef std::future<UpdateGatewayFileShareOutcome> UpdateGatewayFileShareOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::UpdateGatewayFileShareRequest&, const UpdateGatewayFileShareOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayFileShareAsyncHandler;
+			typedef Outcome<Error, Model::UpgradeGatewayResult> UpgradeGatewayOutcome;
+			typedef std::future<UpgradeGatewayOutcome> UpgradeGatewayOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::UpgradeGatewayRequest&, const UpgradeGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpgradeGatewayAsyncHandler;
+			typedef Outcome<Error, Model::UploadGatewayLogResult> UploadGatewayLogOutcome;
+			typedef std::future<UploadGatewayLogOutcome> UploadGatewayLogOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::UploadGatewayLogRequest&, const UploadGatewayLogOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UploadGatewayLogAsyncHandler;
+			typedef Outcome<Error, Model::ValidateExpressSyncConfigResult> ValidateExpressSyncConfigOutcome;
+			typedef std::future<ValidateExpressSyncConfigOutcome> ValidateExpressSyncConfigOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::ValidateExpressSyncConfigRequest&, const ValidateExpressSyncConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ValidateExpressSyncConfigAsyncHandler;
+			typedef Outcome<Error, Model::ValidateGatewayNameResult> ValidateGatewayNameOutcome;
+			typedef std::future<ValidateGatewayNameOutcome> ValidateGatewayNameOutcomeCallable;
+			typedef std::function<void(const SgwClient*, const Model::ValidateGatewayNameRequest&, const ValidateGatewayNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ValidateGatewayNameAsyncHandler;
+
+			SgwClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			SgwClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			SgwClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~SgwClient();
+			ActivateAllInOneGatewayOutcome activateAllInOneGateway(const Model::ActivateAllInOneGatewayRequest &request)const;
+			void activateAllInOneGatewayAsync(const Model::ActivateAllInOneGatewayRequest& request, const ActivateAllInOneGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ActivateAllInOneGatewayOutcomeCallable activateAllInOneGatewayCallable(const Model::ActivateAllInOneGatewayRequest& request) const;
+			ActivateGatewayOutcome activateGateway(const Model::ActivateGatewayRequest &request)const;
+			void activateGatewayAsync(const Model::ActivateGatewayRequest& request, const ActivateGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ActivateGatewayOutcomeCallable activateGatewayCallable(const Model::ActivateGatewayRequest& request) const;
+			AddSharesToExpressSyncOutcome addSharesToExpressSync(const Model::AddSharesToExpressSyncRequest &request)const;
+			void addSharesToExpressSyncAsync(const Model::AddSharesToExpressSyncRequest& request, const AddSharesToExpressSyncAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddSharesToExpressSyncOutcomeCallable addSharesToExpressSyncCallable(const Model::AddSharesToExpressSyncRequest& request) const;
+			AddTagsToGatewayOutcome addTagsToGateway(const Model::AddTagsToGatewayRequest &request)const;
+			void addTagsToGatewayAsync(const Model::AddTagsToGatewayRequest& request, const AddTagsToGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddTagsToGatewayOutcomeCallable addTagsToGatewayCallable(const Model::AddTagsToGatewayRequest& request) const;
+			CheckActivationKeyOutcome checkActivationKey(const Model::CheckActivationKeyRequest &request)const;
+			void checkActivationKeyAsync(const Model::CheckActivationKeyRequest& request, const CheckActivationKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CheckActivationKeyOutcomeCallable checkActivationKeyCallable(const Model::CheckActivationKeyRequest& request) const;
+			CheckBlockVolumeNameOutcome checkBlockVolumeName(const Model::CheckBlockVolumeNameRequest &request)const;
+			void checkBlockVolumeNameAsync(const Model::CheckBlockVolumeNameRequest& request, const CheckBlockVolumeNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CheckBlockVolumeNameOutcomeCallable checkBlockVolumeNameCallable(const Model::CheckBlockVolumeNameRequest& request) const;
+			CheckGatewayEssdSupportOutcome checkGatewayEssdSupport(const Model::CheckGatewayEssdSupportRequest &request)const;
+			void checkGatewayEssdSupportAsync(const Model::CheckGatewayEssdSupportRequest& request, const CheckGatewayEssdSupportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CheckGatewayEssdSupportOutcomeCallable checkGatewayEssdSupportCallable(const Model::CheckGatewayEssdSupportRequest& request) const;
+			CheckMnsServiceOutcome checkMnsService(const Model::CheckMnsServiceRequest &request)const;
+			void checkMnsServiceAsync(const Model::CheckMnsServiceRequest& request, const CheckMnsServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CheckMnsServiceOutcomeCallable checkMnsServiceCallable(const Model::CheckMnsServiceRequest& request) const;
+			CheckRoleOutcome checkRole(const Model::CheckRoleRequest &request)const;
+			void checkRoleAsync(const Model::CheckRoleRequest& request, const CheckRoleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CheckRoleOutcomeCallable checkRoleCallable(const Model::CheckRoleRequest& request) const;
+			CheckSlrRoleOutcome checkSlrRole(const Model::CheckSlrRoleRequest &request)const;
+			void checkSlrRoleAsync(const Model::CheckSlrRoleRequest& request, const CheckSlrRoleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CheckSlrRoleOutcomeCallable checkSlrRoleCallable(const Model::CheckSlrRoleRequest& request) const;
+			CheckUpgradeVersionOutcome checkUpgradeVersion(const Model::CheckUpgradeVersionRequest &request)const;
+			void checkUpgradeVersionAsync(const Model::CheckUpgradeVersionRequest& request, const CheckUpgradeVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CheckUpgradeVersionOutcomeCallable checkUpgradeVersionCallable(const Model::CheckUpgradeVersionRequest& request) const;
+			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;
+			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;
+			CreateGatewayOutcome createGateway(const Model::CreateGatewayRequest &request)const;
+			void createGatewayAsync(const Model::CreateGatewayRequest& request, const CreateGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateGatewayOutcomeCallable createGatewayCallable(const Model::CreateGatewayRequest& request) const;
+			CreateGatewayBlockVolumeOutcome createGatewayBlockVolume(const Model::CreateGatewayBlockVolumeRequest &request)const;
+			void createGatewayBlockVolumeAsync(const Model::CreateGatewayBlockVolumeRequest& request, const CreateGatewayBlockVolumeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateGatewayBlockVolumeOutcomeCallable createGatewayBlockVolumeCallable(const Model::CreateGatewayBlockVolumeRequest& request) const;
+			CreateGatewayCacheDiskOutcome createGatewayCacheDisk(const Model::CreateGatewayCacheDiskRequest &request)const;
+			void createGatewayCacheDiskAsync(const Model::CreateGatewayCacheDiskRequest& request, const CreateGatewayCacheDiskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateGatewayCacheDiskOutcomeCallable createGatewayCacheDiskCallable(const Model::CreateGatewayCacheDiskRequest& request) const;
+			CreateGatewayFileShareOutcome createGatewayFileShare(const Model::CreateGatewayFileShareRequest &request)const;
+			void createGatewayFileShareAsync(const Model::CreateGatewayFileShareRequest& request, const CreateGatewayFileShareAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateGatewayFileShareOutcomeCallable createGatewayFileShareCallable(const Model::CreateGatewayFileShareRequest& request) const;
+			CreateGatewayLoggingOutcome createGatewayLogging(const Model::CreateGatewayLoggingRequest &request)const;
+			void createGatewayLoggingAsync(const Model::CreateGatewayLoggingRequest& request, const CreateGatewayLoggingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateGatewayLoggingOutcomeCallable createGatewayLoggingCallable(const Model::CreateGatewayLoggingRequest& request) const;
+			CreateGatewaySMBUserOutcome createGatewaySMBUser(const Model::CreateGatewaySMBUserRequest &request)const;
+			void createGatewaySMBUserAsync(const Model::CreateGatewaySMBUserRequest& request, const CreateGatewaySMBUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateGatewaySMBUserOutcomeCallable createGatewaySMBUserCallable(const Model::CreateGatewaySMBUserRequest& request) const;
+			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;
+			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;
+			DeleteGatewayOutcome deleteGateway(const Model::DeleteGatewayRequest &request)const;
+			void deleteGatewayAsync(const Model::DeleteGatewayRequest& request, const DeleteGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteGatewayOutcomeCallable deleteGatewayCallable(const Model::DeleteGatewayRequest& request) const;
+			DeleteGatewayBlockVolumesOutcome deleteGatewayBlockVolumes(const Model::DeleteGatewayBlockVolumesRequest &request)const;
+			void deleteGatewayBlockVolumesAsync(const Model::DeleteGatewayBlockVolumesRequest& request, const DeleteGatewayBlockVolumesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteGatewayBlockVolumesOutcomeCallable deleteGatewayBlockVolumesCallable(const Model::DeleteGatewayBlockVolumesRequest& request) const;
+			DeleteGatewayCacheDiskOutcome deleteGatewayCacheDisk(const Model::DeleteGatewayCacheDiskRequest &request)const;
+			void deleteGatewayCacheDiskAsync(const Model::DeleteGatewayCacheDiskRequest& request, const DeleteGatewayCacheDiskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteGatewayCacheDiskOutcomeCallable deleteGatewayCacheDiskCallable(const Model::DeleteGatewayCacheDiskRequest& request) const;
+			DeleteGatewayFileSharesOutcome deleteGatewayFileShares(const Model::DeleteGatewayFileSharesRequest &request)const;
+			void deleteGatewayFileSharesAsync(const Model::DeleteGatewayFileSharesRequest& request, const DeleteGatewayFileSharesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteGatewayFileSharesOutcomeCallable deleteGatewayFileSharesCallable(const Model::DeleteGatewayFileSharesRequest& request) const;
+			DeleteGatewayLoggingOutcome deleteGatewayLogging(const Model::DeleteGatewayLoggingRequest &request)const;
+			void deleteGatewayLoggingAsync(const Model::DeleteGatewayLoggingRequest& request, const DeleteGatewayLoggingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteGatewayLoggingOutcomeCallable deleteGatewayLoggingCallable(const Model::DeleteGatewayLoggingRequest& request) const;
+			DeleteGatewaySMBUserOutcome deleteGatewaySMBUser(const Model::DeleteGatewaySMBUserRequest &request)const;
+			void deleteGatewaySMBUserAsync(const Model::DeleteGatewaySMBUserRequest& request, const DeleteGatewaySMBUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteGatewaySMBUserOutcomeCallable deleteGatewaySMBUserCallable(const Model::DeleteGatewaySMBUserRequest& request) const;
+			DeleteStorageBundleOutcome deleteStorageBundle(const Model::DeleteStorageBundleRequest &request)const;
+			void deleteStorageBundleAsync(const Model::DeleteStorageBundleRequest& request, const DeleteStorageBundleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteStorageBundleOutcomeCallable deleteStorageBundleCallable(const Model::DeleteStorageBundleRequest& request) const;
+			DeployCacheDiskOutcome deployCacheDisk(const Model::DeployCacheDiskRequest &request)const;
+			void deployCacheDiskAsync(const Model::DeployCacheDiskRequest& request, const DeployCacheDiskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeployCacheDiskOutcomeCallable deployCacheDiskCallable(const Model::DeployCacheDiskRequest& request) const;
+			DeployGatewayOutcome deployGateway(const Model::DeployGatewayRequest &request)const;
+			void deployGatewayAsync(const Model::DeployGatewayRequest& request, const DeployGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeployGatewayOutcomeCallable deployGatewayCallable(const Model::DeployGatewayRequest& request) const;
+			DescribeAccountConfigOutcome describeAccountConfig(const Model::DescribeAccountConfigRequest &request)const;
+			void describeAccountConfigAsync(const Model::DescribeAccountConfigRequest& request, const DescribeAccountConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeAccountConfigOutcomeCallable describeAccountConfigCallable(const Model::DescribeAccountConfigRequest& request) const;
+			DescribeBlockVolumeSnapshotsOutcome describeBlockVolumeSnapshots(const Model::DescribeBlockVolumeSnapshotsRequest &request)const;
+			void describeBlockVolumeSnapshotsAsync(const Model::DescribeBlockVolumeSnapshotsRequest& request, const DescribeBlockVolumeSnapshotsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeBlockVolumeSnapshotsOutcomeCallable describeBlockVolumeSnapshotsCallable(const Model::DescribeBlockVolumeSnapshotsRequest& request) const;
+			DescribeDashboardOutcome describeDashboard(const Model::DescribeDashboardRequest &request)const;
+			void describeDashboardAsync(const Model::DescribeDashboardRequest& request, const DescribeDashboardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDashboardOutcomeCallable describeDashboardCallable(const Model::DescribeDashboardRequest& request) const;
+			DescribeExpireCachesOutcome describeExpireCaches(const Model::DescribeExpireCachesRequest &request)const;
+			void describeExpireCachesAsync(const Model::DescribeExpireCachesRequest& request, const DescribeExpireCachesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeExpireCachesOutcomeCallable describeExpireCachesCallable(const Model::DescribeExpireCachesRequest& request) const;
+			DescribeExpressSyncSharesOutcome describeExpressSyncShares(const Model::DescribeExpressSyncSharesRequest &request)const;
+			void describeExpressSyncSharesAsync(const Model::DescribeExpressSyncSharesRequest& request, const DescribeExpressSyncSharesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeExpressSyncSharesOutcomeCallable describeExpressSyncSharesCallable(const Model::DescribeExpressSyncSharesRequest& request) const;
+			DescribeExpressSyncsOutcome describeExpressSyncs(const Model::DescribeExpressSyncsRequest &request)const;
+			void describeExpressSyncsAsync(const Model::DescribeExpressSyncsRequest& request, const DescribeExpressSyncsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeExpressSyncsOutcomeCallable describeExpressSyncsCallable(const Model::DescribeExpressSyncsRequest& request) const;
+			DescribeGatewayOutcome describeGateway(const Model::DescribeGatewayRequest &request)const;
+			void describeGatewayAsync(const Model::DescribeGatewayRequest& request, const DescribeGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayOutcomeCallable describeGatewayCallable(const Model::DescribeGatewayRequest& request) const;
+			DescribeGatewayADInfoOutcome describeGatewayADInfo(const Model::DescribeGatewayADInfoRequest &request)const;
+			void describeGatewayADInfoAsync(const Model::DescribeGatewayADInfoRequest& request, const DescribeGatewayADInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayADInfoOutcomeCallable describeGatewayADInfoCallable(const Model::DescribeGatewayADInfoRequest& request) const;
+			DescribeGatewayActionsOutcome describeGatewayActions(const Model::DescribeGatewayActionsRequest &request)const;
+			void describeGatewayActionsAsync(const Model::DescribeGatewayActionsRequest& request, const DescribeGatewayActionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayActionsOutcomeCallable describeGatewayActionsCallable(const Model::DescribeGatewayActionsRequest& request) const;
+			DescribeGatewayAuthInfoOutcome describeGatewayAuthInfo(const Model::DescribeGatewayAuthInfoRequest &request)const;
+			void describeGatewayAuthInfoAsync(const Model::DescribeGatewayAuthInfoRequest& request, const DescribeGatewayAuthInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayAuthInfoOutcomeCallable describeGatewayAuthInfoCallable(const Model::DescribeGatewayAuthInfoRequest& request) const;
+			DescribeGatewayBlockVolumesOutcome describeGatewayBlockVolumes(const Model::DescribeGatewayBlockVolumesRequest &request)const;
+			void describeGatewayBlockVolumesAsync(const Model::DescribeGatewayBlockVolumesRequest& request, const DescribeGatewayBlockVolumesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayBlockVolumesOutcomeCallable describeGatewayBlockVolumesCallable(const Model::DescribeGatewayBlockVolumesRequest& request) const;
+			DescribeGatewayBucketCachesOutcome describeGatewayBucketCaches(const Model::DescribeGatewayBucketCachesRequest &request)const;
+			void describeGatewayBucketCachesAsync(const Model::DescribeGatewayBucketCachesRequest& request, const DescribeGatewayBucketCachesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayBucketCachesOutcomeCallable describeGatewayBucketCachesCallable(const Model::DescribeGatewayBucketCachesRequest& request) const;
+			DescribeGatewayCachesOutcome describeGatewayCaches(const Model::DescribeGatewayCachesRequest &request)const;
+			void describeGatewayCachesAsync(const Model::DescribeGatewayCachesRequest& request, const DescribeGatewayCachesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayCachesOutcomeCallable describeGatewayCachesCallable(const Model::DescribeGatewayCachesRequest& request) const;
+			DescribeGatewayCapacityLimitOutcome describeGatewayCapacityLimit(const Model::DescribeGatewayCapacityLimitRequest &request)const;
+			void describeGatewayCapacityLimitAsync(const Model::DescribeGatewayCapacityLimitRequest& request, const DescribeGatewayCapacityLimitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayCapacityLimitOutcomeCallable describeGatewayCapacityLimitCallable(const Model::DescribeGatewayCapacityLimitRequest& request) const;
+			DescribeGatewayCategoriesOutcome describeGatewayCategories(const Model::DescribeGatewayCategoriesRequest &request)const;
+			void describeGatewayCategoriesAsync(const Model::DescribeGatewayCategoriesRequest& request, const DescribeGatewayCategoriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayCategoriesOutcomeCallable describeGatewayCategoriesCallable(const Model::DescribeGatewayCategoriesRequest& request) const;
+			DescribeGatewayClassesOutcome describeGatewayClasses(const Model::DescribeGatewayClassesRequest &request)const;
+			void describeGatewayClassesAsync(const Model::DescribeGatewayClassesRequest& request, const DescribeGatewayClassesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayClassesOutcomeCallable describeGatewayClassesCallable(const Model::DescribeGatewayClassesRequest& request) const;
+			DescribeGatewayCredentialOutcome describeGatewayCredential(const Model::DescribeGatewayCredentialRequest &request)const;
+			void describeGatewayCredentialAsync(const Model::DescribeGatewayCredentialRequest& request, const DescribeGatewayCredentialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayCredentialOutcomeCallable describeGatewayCredentialCallable(const Model::DescribeGatewayCredentialRequest& request) const;
+			DescribeGatewayDNSOutcome describeGatewayDNS(const Model::DescribeGatewayDNSRequest &request)const;
+			void describeGatewayDNSAsync(const Model::DescribeGatewayDNSRequest& request, const DescribeGatewayDNSAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayDNSOutcomeCallable describeGatewayDNSCallable(const Model::DescribeGatewayDNSRequest& request) const;
+			DescribeGatewayFileSharesOutcome describeGatewayFileShares(const Model::DescribeGatewayFileSharesRequest &request)const;
+			void describeGatewayFileSharesAsync(const Model::DescribeGatewayFileSharesRequest& request, const DescribeGatewayFileSharesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayFileSharesOutcomeCallable describeGatewayFileSharesCallable(const Model::DescribeGatewayFileSharesRequest& request) const;
+			DescribeGatewayFileStatusOutcome describeGatewayFileStatus(const Model::DescribeGatewayFileStatusRequest &request)const;
+			void describeGatewayFileStatusAsync(const Model::DescribeGatewayFileStatusRequest& request, const DescribeGatewayFileStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayFileStatusOutcomeCallable describeGatewayFileStatusCallable(const Model::DescribeGatewayFileStatusRequest& request) const;
+			DescribeGatewayImagesOutcome describeGatewayImages(const Model::DescribeGatewayImagesRequest &request)const;
+			void describeGatewayImagesAsync(const Model::DescribeGatewayImagesRequest& request, const DescribeGatewayImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayImagesOutcomeCallable describeGatewayImagesCallable(const Model::DescribeGatewayImagesRequest& request) const;
+			DescribeGatewayInfoOutcome describeGatewayInfo(const Model::DescribeGatewayInfoRequest &request)const;
+			void describeGatewayInfoAsync(const Model::DescribeGatewayInfoRequest& request, const DescribeGatewayInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayInfoOutcomeCallable describeGatewayInfoCallable(const Model::DescribeGatewayInfoRequest& request) const;
+			DescribeGatewayLDAPInfoOutcome describeGatewayLDAPInfo(const Model::DescribeGatewayLDAPInfoRequest &request)const;
+			void describeGatewayLDAPInfoAsync(const Model::DescribeGatewayLDAPInfoRequest& request, const DescribeGatewayLDAPInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayLDAPInfoOutcomeCallable describeGatewayLDAPInfoCallable(const Model::DescribeGatewayLDAPInfoRequest& request) const;
+			DescribeGatewayLocationsOutcome describeGatewayLocations(const Model::DescribeGatewayLocationsRequest &request)const;
+			void describeGatewayLocationsAsync(const Model::DescribeGatewayLocationsRequest& request, const DescribeGatewayLocationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayLocationsOutcomeCallable describeGatewayLocationsCallable(const Model::DescribeGatewayLocationsRequest& request) const;
+			DescribeGatewayLoggingOutcome describeGatewayLogging(const Model::DescribeGatewayLoggingRequest &request)const;
+			void describeGatewayLoggingAsync(const Model::DescribeGatewayLoggingRequest& request, const DescribeGatewayLoggingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayLoggingOutcomeCallable describeGatewayLoggingCallable(const Model::DescribeGatewayLoggingRequest& request) const;
+			DescribeGatewayLogsOutcome describeGatewayLogs(const Model::DescribeGatewayLogsRequest &request)const;
+			void describeGatewayLogsAsync(const Model::DescribeGatewayLogsRequest& request, const DescribeGatewayLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayLogsOutcomeCallable describeGatewayLogsCallable(const Model::DescribeGatewayLogsRequest& request) const;
+			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;
+			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;
+			DescribeGatewayStatisticsOutcome describeGatewayStatistics(const Model::DescribeGatewayStatisticsRequest &request)const;
+			void describeGatewayStatisticsAsync(const Model::DescribeGatewayStatisticsRequest& request, const DescribeGatewayStatisticsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayStatisticsOutcomeCallable describeGatewayStatisticsCallable(const Model::DescribeGatewayStatisticsRequest& request) const;
+			DescribeGatewayStockOutcome describeGatewayStock(const Model::DescribeGatewayStockRequest &request)const;
+			void describeGatewayStockAsync(const Model::DescribeGatewayStockRequest& request, const DescribeGatewayStockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayStockOutcomeCallable describeGatewayStockCallable(const Model::DescribeGatewayStockRequest& request) const;
+			DescribeGatewayTypesOutcome describeGatewayTypes(const Model::DescribeGatewayTypesRequest &request)const;
+			void describeGatewayTypesAsync(const Model::DescribeGatewayTypesRequest& request, const DescribeGatewayTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewayTypesOutcomeCallable describeGatewayTypesCallable(const Model::DescribeGatewayTypesRequest& request) const;
+			DescribeGatewaysOutcome describeGateways(const Model::DescribeGatewaysRequest &request)const;
+			void describeGatewaysAsync(const Model::DescribeGatewaysRequest& request, const DescribeGatewaysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewaysOutcomeCallable describeGatewaysCallable(const Model::DescribeGatewaysRequest& request) const;
+			DescribeGatewaysForCmsOutcome describeGatewaysForCms(const Model::DescribeGatewaysForCmsRequest &request)const;
+			void describeGatewaysForCmsAsync(const Model::DescribeGatewaysForCmsRequest& request, const DescribeGatewaysForCmsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewaysForCmsOutcomeCallable describeGatewaysForCmsCallable(const Model::DescribeGatewaysForCmsRequest& request) const;
+			DescribeGatewaysTagsOutcome describeGatewaysTags(const Model::DescribeGatewaysTagsRequest &request)const;
+			void describeGatewaysTagsAsync(const Model::DescribeGatewaysTagsRequest& request, const DescribeGatewaysTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGatewaysTagsOutcomeCallable describeGatewaysTagsCallable(const Model::DescribeGatewaysTagsRequest& request) const;
+			DescribeKmsKeyOutcome describeKmsKey(const Model::DescribeKmsKeyRequest &request)const;
+			void describeKmsKeyAsync(const Model::DescribeKmsKeyRequest& request, const DescribeKmsKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeKmsKeyOutcomeCallable describeKmsKeyCallable(const Model::DescribeKmsKeyRequest& request) const;
+			DescribeMqttConfigOutcome describeMqttConfig(const Model::DescribeMqttConfigRequest &request)const;
+			void describeMqttConfigAsync(const Model::DescribeMqttConfigRequest& request, const DescribeMqttConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeMqttConfigOutcomeCallable describeMqttConfigCallable(const Model::DescribeMqttConfigRequest& request) const;
+			DescribeOssBucketInfoOutcome describeOssBucketInfo(const Model::DescribeOssBucketInfoRequest &request)const;
+			void describeOssBucketInfoAsync(const Model::DescribeOssBucketInfoRequest& request, const DescribeOssBucketInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeOssBucketInfoOutcomeCallable describeOssBucketInfoCallable(const Model::DescribeOssBucketInfoRequest& request) const;
+			DescribeOssBucketsOutcome describeOssBuckets(const Model::DescribeOssBucketsRequest &request)const;
+			void describeOssBucketsAsync(const Model::DescribeOssBucketsRequest& request, const DescribeOssBucketsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeOssBucketsOutcomeCallable describeOssBucketsCallable(const Model::DescribeOssBucketsRequest& request) const;
+			DescribePayAsYouGoPriceOutcome describePayAsYouGoPrice(const Model::DescribePayAsYouGoPriceRequest &request)const;
+			void describePayAsYouGoPriceAsync(const Model::DescribePayAsYouGoPriceRequest& request, const DescribePayAsYouGoPriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribePayAsYouGoPriceOutcomeCallable describePayAsYouGoPriceCallable(const Model::DescribePayAsYouGoPriceRequest& request) const;
+			DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
+			void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
+			DescribeSharesBucketInfoForExpressSyncOutcome describeSharesBucketInfoForExpressSync(const Model::DescribeSharesBucketInfoForExpressSyncRequest &request)const;
+			void describeSharesBucketInfoForExpressSyncAsync(const Model::DescribeSharesBucketInfoForExpressSyncRequest& request, const DescribeSharesBucketInfoForExpressSyncAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeSharesBucketInfoForExpressSyncOutcomeCallable describeSharesBucketInfoForExpressSyncCallable(const Model::DescribeSharesBucketInfoForExpressSyncRequest& request) const;
+			DescribeStorageBundleOutcome describeStorageBundle(const Model::DescribeStorageBundleRequest &request)const;
+			void describeStorageBundleAsync(const Model::DescribeStorageBundleRequest& request, const DescribeStorageBundleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeStorageBundleOutcomeCallable describeStorageBundleCallable(const Model::DescribeStorageBundleRequest& request) const;
+			DescribeStorageBundlesOutcome describeStorageBundles(const Model::DescribeStorageBundlesRequest &request)const;
+			void describeStorageBundlesAsync(const Model::DescribeStorageBundlesRequest& request, const DescribeStorageBundlesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeStorageBundlesOutcomeCallable describeStorageBundlesCallable(const Model::DescribeStorageBundlesRequest& request) const;
+			DescribeSubscriptionPriceOutcome describeSubscriptionPrice(const Model::DescribeSubscriptionPriceRequest &request)const;
+			void describeSubscriptionPriceAsync(const Model::DescribeSubscriptionPriceRequest& request, const DescribeSubscriptionPriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeSubscriptionPriceOutcomeCallable describeSubscriptionPriceCallable(const Model::DescribeSubscriptionPriceRequest& request) const;
+			DescribeTasksOutcome describeTasks(const Model::DescribeTasksRequest &request)const;
+			void describeTasksAsync(const Model::DescribeTasksRequest& request, const DescribeTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeTasksOutcomeCallable describeTasksCallable(const Model::DescribeTasksRequest& request) const;
+			DescribeUserBusinessStatusOutcome describeUserBusinessStatus(const Model::DescribeUserBusinessStatusRequest &request)const;
+			void describeUserBusinessStatusAsync(const Model::DescribeUserBusinessStatusRequest& request, const DescribeUserBusinessStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeUserBusinessStatusOutcomeCallable describeUserBusinessStatusCallable(const Model::DescribeUserBusinessStatusRequest& request) const;
+			DescribeVSwitchesOutcome describeVSwitches(const Model::DescribeVSwitchesRequest &request)const;
+			void describeVSwitchesAsync(const Model::DescribeVSwitchesRequest& request, const DescribeVSwitchesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeVSwitchesOutcomeCallable describeVSwitchesCallable(const Model::DescribeVSwitchesRequest& request) const;
+			DescribeVpcsOutcome describeVpcs(const Model::DescribeVpcsRequest &request)const;
+			void describeVpcsAsync(const Model::DescribeVpcsRequest& request, const DescribeVpcsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeVpcsOutcomeCallable describeVpcsCallable(const Model::DescribeVpcsRequest& request) const;
+			DescribeZonesOutcome describeZones(const Model::DescribeZonesRequest &request)const;
+			void describeZonesAsync(const Model::DescribeZonesRequest& request, const DescribeZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeZonesOutcomeCallable describeZonesCallable(const Model::DescribeZonesRequest& request) const;
+			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;
+			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;
+			ExpandCacheDiskOutcome expandCacheDisk(const Model::ExpandCacheDiskRequest &request)const;
+			void expandCacheDiskAsync(const Model::ExpandCacheDiskRequest& request, const ExpandCacheDiskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ExpandCacheDiskOutcomeCallable expandCacheDiskCallable(const Model::ExpandCacheDiskRequest& request) const;
+			ExpandGatewayNetworkBandwidthOutcome expandGatewayNetworkBandwidth(const Model::ExpandGatewayNetworkBandwidthRequest &request)const;
+			void expandGatewayNetworkBandwidthAsync(const Model::ExpandGatewayNetworkBandwidthRequest& request, const ExpandGatewayNetworkBandwidthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ExpandGatewayNetworkBandwidthOutcomeCallable expandGatewayNetworkBandwidthCallable(const Model::ExpandGatewayNetworkBandwidthRequest& request) const;
+			GenerateGatewayTokenOutcome generateGatewayToken(const Model::GenerateGatewayTokenRequest &request)const;
+			void generateGatewayTokenAsync(const Model::GenerateGatewayTokenRequest& request, const GenerateGatewayTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GenerateGatewayTokenOutcomeCallable generateGatewayTokenCallable(const Model::GenerateGatewayTokenRequest& request) const;
+			GenerateMqttTokenOutcome generateMqttToken(const Model::GenerateMqttTokenRequest &request)const;
+			void generateMqttTokenAsync(const Model::GenerateMqttTokenRequest& request, const GenerateMqttTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GenerateMqttTokenOutcomeCallable generateMqttTokenCallable(const Model::GenerateMqttTokenRequest& request) const;
+			GenerateStsTokenOutcome generateStsToken(const Model::GenerateStsTokenRequest &request)const;
+			void generateStsTokenAsync(const Model::GenerateStsTokenRequest& request, const GenerateStsTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GenerateStsTokenOutcomeCallable generateStsTokenCallable(const Model::GenerateStsTokenRequest& request) const;
+			ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const;
+			void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const;
+			ModifyGatewayOutcome modifyGateway(const Model::ModifyGatewayRequest &request)const;
+			void modifyGatewayAsync(const Model::ModifyGatewayRequest& request, const ModifyGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyGatewayOutcomeCallable modifyGatewayCallable(const Model::ModifyGatewayRequest& request) const;
+			ModifyGatewayBlockVolumeOutcome modifyGatewayBlockVolume(const Model::ModifyGatewayBlockVolumeRequest &request)const;
+			void modifyGatewayBlockVolumeAsync(const Model::ModifyGatewayBlockVolumeRequest& request, const ModifyGatewayBlockVolumeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyGatewayBlockVolumeOutcomeCallable modifyGatewayBlockVolumeCallable(const Model::ModifyGatewayBlockVolumeRequest& request) const;
+			ModifyGatewayClassOutcome modifyGatewayClass(const Model::ModifyGatewayClassRequest &request)const;
+			void modifyGatewayClassAsync(const Model::ModifyGatewayClassRequest& request, const ModifyGatewayClassAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyGatewayClassOutcomeCallable modifyGatewayClassCallable(const Model::ModifyGatewayClassRequest& request) const;
+			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;
+			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;
+			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;
+			ReleaseServiceOutcome releaseService(const Model::ReleaseServiceRequest &request)const;
+			void releaseServiceAsync(const Model::ReleaseServiceRequest& request, const ReleaseServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ReleaseServiceOutcomeCallable releaseServiceCallable(const Model::ReleaseServiceRequest& request) const;
+			RemoveSharesFromExpressSyncOutcome removeSharesFromExpressSync(const Model::RemoveSharesFromExpressSyncRequest &request)const;
+			void removeSharesFromExpressSyncAsync(const Model::RemoveSharesFromExpressSyncRequest& request, const RemoveSharesFromExpressSyncAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RemoveSharesFromExpressSyncOutcomeCallable removeSharesFromExpressSyncCallable(const Model::RemoveSharesFromExpressSyncRequest& request) const;
+			RemoveTagsFromGatewayOutcome removeTagsFromGateway(const Model::RemoveTagsFromGatewayRequest &request)const;
+			void removeTagsFromGatewayAsync(const Model::RemoveTagsFromGatewayRequest& request, const RemoveTagsFromGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RemoveTagsFromGatewayOutcomeCallable removeTagsFromGatewayCallable(const Model::RemoveTagsFromGatewayRequest& request) const;
+			ReportBlockVolumesOutcome reportBlockVolumes(const Model::ReportBlockVolumesRequest &request)const;
+			void reportBlockVolumesAsync(const Model::ReportBlockVolumesRequest& request, const ReportBlockVolumesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ReportBlockVolumesOutcomeCallable reportBlockVolumesCallable(const Model::ReportBlockVolumesRequest& request) const;
+			ReportFileSharesOutcome reportFileShares(const Model::ReportFileSharesRequest &request)const;
+			void reportFileSharesAsync(const Model::ReportFileSharesRequest& request, const ReportFileSharesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ReportFileSharesOutcomeCallable reportFileSharesCallable(const Model::ReportFileSharesRequest& request) const;
+			ReportGatewayInfoOutcome reportGatewayInfo(const Model::ReportGatewayInfoRequest &request)const;
+			void reportGatewayInfoAsync(const Model::ReportGatewayInfoRequest& request, const ReportGatewayInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ReportGatewayInfoOutcomeCallable reportGatewayInfoCallable(const Model::ReportGatewayInfoRequest& request) const;
+			ReportGatewayUsageOutcome reportGatewayUsage(const Model::ReportGatewayUsageRequest &request)const;
+			void reportGatewayUsageAsync(const Model::ReportGatewayUsageRequest& request, const ReportGatewayUsageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ReportGatewayUsageOutcomeCallable reportGatewayUsageCallable(const Model::ReportGatewayUsageRequest& request) const;
+			ResetGatewayPasswordOutcome resetGatewayPassword(const Model::ResetGatewayPasswordRequest &request)const;
+			void resetGatewayPasswordAsync(const Model::ResetGatewayPasswordRequest& request, const ResetGatewayPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ResetGatewayPasswordOutcomeCallable resetGatewayPasswordCallable(const Model::ResetGatewayPasswordRequest& request) const;
+			RestartFileSharesOutcome restartFileShares(const Model::RestartFileSharesRequest &request)const;
+			void restartFileSharesAsync(const Model::RestartFileSharesRequest& request, const RestartFileSharesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RestartFileSharesOutcomeCallable restartFileSharesCallable(const Model::RestartFileSharesRequest& request) const;
+			SetGatewayADInfoOutcome setGatewayADInfo(const Model::SetGatewayADInfoRequest &request)const;
+			void setGatewayADInfoAsync(const Model::SetGatewayADInfoRequest& request, const SetGatewayADInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetGatewayADInfoOutcomeCallable setGatewayADInfoCallable(const Model::SetGatewayADInfoRequest& request) const;
+			SetGatewayDNSOutcome setGatewayDNS(const Model::SetGatewayDNSRequest &request)const;
+			void setGatewayDNSAsync(const Model::SetGatewayDNSRequest& request, const SetGatewayDNSAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetGatewayDNSOutcomeCallable setGatewayDNSCallable(const Model::SetGatewayDNSRequest& request) const;
+			SetGatewayLDAPInfoOutcome setGatewayLDAPInfo(const Model::SetGatewayLDAPInfoRequest &request)const;
+			void setGatewayLDAPInfoAsync(const Model::SetGatewayLDAPInfoRequest& request, const SetGatewayLDAPInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetGatewayLDAPInfoOutcomeCallable setGatewayLDAPInfoCallable(const Model::SetGatewayLDAPInfoRequest& request) const;
+			SwitchGatewayExpirationPolicyOutcome switchGatewayExpirationPolicy(const Model::SwitchGatewayExpirationPolicyRequest &request)const;
+			void switchGatewayExpirationPolicyAsync(const Model::SwitchGatewayExpirationPolicyRequest& request, const SwitchGatewayExpirationPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SwitchGatewayExpirationPolicyOutcomeCallable switchGatewayExpirationPolicyCallable(const Model::SwitchGatewayExpirationPolicyRequest& request) const;
+			SwitchToSubscriptionOutcome switchToSubscription(const Model::SwitchToSubscriptionRequest &request)const;
+			void switchToSubscriptionAsync(const Model::SwitchToSubscriptionRequest& request, const SwitchToSubscriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SwitchToSubscriptionOutcomeCallable switchToSubscriptionCallable(const Model::SwitchToSubscriptionRequest& request) const;
+			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;
+			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;
+			UpdateGatewayBlockVolumeOutcome updateGatewayBlockVolume(const Model::UpdateGatewayBlockVolumeRequest &request)const;
+			void updateGatewayBlockVolumeAsync(const Model::UpdateGatewayBlockVolumeRequest& request, const UpdateGatewayBlockVolumeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateGatewayBlockVolumeOutcomeCallable updateGatewayBlockVolumeCallable(const Model::UpdateGatewayBlockVolumeRequest& request) const;
+			UpdateGatewayFileShareOutcome updateGatewayFileShare(const Model::UpdateGatewayFileShareRequest &request)const;
+			void updateGatewayFileShareAsync(const Model::UpdateGatewayFileShareRequest& request, const UpdateGatewayFileShareAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateGatewayFileShareOutcomeCallable updateGatewayFileShareCallable(const Model::UpdateGatewayFileShareRequest& request) const;
+			UpgradeGatewayOutcome upgradeGateway(const Model::UpgradeGatewayRequest &request)const;
+			void upgradeGatewayAsync(const Model::UpgradeGatewayRequest& request, const UpgradeGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpgradeGatewayOutcomeCallable upgradeGatewayCallable(const Model::UpgradeGatewayRequest& request) const;
+			UploadGatewayLogOutcome uploadGatewayLog(const Model::UploadGatewayLogRequest &request)const;
+			void uploadGatewayLogAsync(const Model::UploadGatewayLogRequest& request, const UploadGatewayLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UploadGatewayLogOutcomeCallable uploadGatewayLogCallable(const Model::UploadGatewayLogRequest& request) const;
+			ValidateExpressSyncConfigOutcome validateExpressSyncConfig(const Model::ValidateExpressSyncConfigRequest &request)const;
+			void validateExpressSyncConfigAsync(const Model::ValidateExpressSyncConfigRequest& request, const ValidateExpressSyncConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ValidateExpressSyncConfigOutcomeCallable validateExpressSyncConfigCallable(const Model::ValidateExpressSyncConfigRequest& request) const;
+			ValidateGatewayNameOutcome validateGatewayName(const Model::ValidateGatewayNameRequest &request)const;
+			void validateGatewayNameAsync(const Model::ValidateGatewayNameRequest& request, const ValidateGatewayNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ValidateGatewayNameOutcomeCallable validateGatewayNameCallable(const Model::ValidateGatewayNameRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_SGW_SGWCLIENT_H_

sgw/include/alibabacloud/sgw/SgwExport.h

@@ -0,0 +1,32 @@
+/*
+ * 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_SGWEXPORT_H_
+#define ALIBABACLOUD_SGW_SGWEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_SGW_LIBRARY)
+#		define ALIBABACLOUD_SGW_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_SGW_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_SGW_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_SGW_SGWEXPORT_H_

sgw/include/alibabacloud/sgw/model/ActivateAllInOneGatewayRequest.h

@@ -0,0 +1,66 @@
+/*
+ * 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_ACTIVATEALLINONEGATEWAYREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_ACTIVATEALLINONEGATEWAYREQUEST_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 ActivateAllInOneGatewayRequest : public RpcServiceRequest
+			{
+
+			public:
+				ActivateAllInOneGatewayRequest();
+				~ActivateAllInOneGatewayRequest();
+
+				std::string getClientUUID()const;
+				void setClientUUID(const std::string& clientUUID);
+				std::string getSerialNumber()const;
+				void setSerialNumber(const std::string& serialNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getDeviceNumber()const;
+				void setDeviceNumber(const std::string& deviceNumber);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getModel()const;
+				void setModel(const std::string& model);
+				std::string getGatewayId()const;
+				void setGatewayId(const std::string& gatewayId);
+
+            private:
+				std::string clientUUID_;
+				std::string serialNumber_;
+				std::string accessKeyId_;
+				std::string deviceNumber_;
+				std::string securityToken_;
+				std::string model_;
+				std::string gatewayId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_ACTIVATEALLINONEGATEWAYREQUEST_H_

sgw/include/alibabacloud/sgw/model/ActivateAllInOneGatewayResult.h

@@ -0,0 +1,61 @@
+/*
+ * 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_ACTIVATEALLINONEGATEWAYRESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_ACTIVATEALLINONEGATEWAYRESULT_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 ActivateAllInOneGatewayResult : public ServiceResult
+			{
+			public:
+
+
+				ActivateAllInOneGatewayResult();
+				explicit ActivateAllInOneGatewayResult(const std::string &payload);
+				~ActivateAllInOneGatewayResult();
+				std::string getMessage()const;
+				std::string getRegionId()const;
+				std::string getGatewayId()const;
+				std::string getCode()const;
+				std::string getLicenseContent()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string regionId_;
+				std::string gatewayId_;
+				std::string code_;
+				std::string licenseContent_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_ACTIVATEALLINONEGATEWAYRESULT_H_

sgw/include/alibabacloud/sgw/model/ActivateGatewayRequest.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SGW_MODEL_ACTIVATEGATEWAYREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_ACTIVATEGATEWAYREQUEST_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 ActivateGatewayRequest : public RpcServiceRequest
+			{
+
+			public:
+				ActivateGatewayRequest();
+				~ActivateGatewayRequest();
+
+				std::string getClientUUID()const;
+				void setClientUUID(const std::string& clientUUID);
+				std::string getSerialNumber()const;
+				void setSerialNumber(const std::string& serialNumber);
+				std::string getType()const;
+				void setType(const std::string& type);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getToken()const;
+				void setToken(const std::string& token);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getModel()const;
+				void setModel(const std::string& model);
+				std::string getCategory()const;
+				void setCategory(const std::string& category);
+
+            private:
+				std::string clientUUID_;
+				std::string serialNumber_;
+				std::string type_;
+				std::string accessKeyId_;
+				std::string token_;
+				std::string securityToken_;
+				std::string model_;
+				std::string category_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_ACTIVATEGATEWAYREQUEST_H_

sgw/include/alibabacloud/sgw/model/ActivateGatewayResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SGW_MODEL_ACTIVATEGATEWAYRESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_ACTIVATEGATEWAYRESULT_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 ActivateGatewayResult : public ServiceResult
+			{
+			public:
+
+
+				ActivateGatewayResult();
+				explicit ActivateGatewayResult(const std::string &payload);
+				~ActivateGatewayResult();
+				std::string getMessage()const;
+				std::string getRegionId()const;
+				std::string getGatewayId()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string regionId_;
+				std::string gatewayId_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_ACTIVATEGATEWAYRESULT_H_

sgw/include/alibabacloud/sgw/model/AddSharesToExpressSyncRequest.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_ADDSHARESTOEXPRESSSYNCREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_ADDSHARESTOEXPRESSSYNCREQUEST_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 AddSharesToExpressSyncRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddSharesToExpressSyncRequest();
+				~AddSharesToExpressSyncRequest();
+
+				std::string getExpressSyncId()const;
+				void setExpressSyncId(const std::string& expressSyncId);
+				std::string getGatewayShares()const;
+				void setGatewayShares(const std::string& gatewayShares);
+				std::string getGatewayRegions()const;
+				void setGatewayRegions(const std::string& gatewayRegions);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+
+            private:
+				std::string expressSyncId_;
+				std::string gatewayShares_;
+				std::string gatewayRegions_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_ADDSHARESTOEXPRESSSYNCREQUEST_H_

sgw/include/alibabacloud/sgw/model/AddSharesToExpressSyncResult.h

@@ -0,0 +1,67 @@
+/*
+ * 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_ADDSHARESTOEXPRESSSYNCRESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_ADDSHARESTOEXPRESSSYNCRESULT_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 AddSharesToExpressSyncResult : public ServiceResult
+			{
+			public:
+
+
+				AddSharesToExpressSyncResult();
+				explicit AddSharesToExpressSyncResult(const std::string &payload);
+				~AddSharesToExpressSyncResult();
+				std::string getTaskId()const;
+				std::string getMessage()const;
+				std::string getMnsTopic()const;
+				std::string getMnsQueues()const;
+				long getMnsFullSyncDelay()const;
+				std::string getMnsPublicEndpoint()const;
+				std::string getCode()const;
+				std::string getMnsInnerEndpoint()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string taskId_;
+				std::string message_;
+				std::string mnsTopic_;
+				std::string mnsQueues_;
+				long mnsFullSyncDelay_;
+				std::string mnsPublicEndpoint_;
+				std::string code_;
+				std::string mnsInnerEndpoint_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_ADDSHARESTOEXPRESSSYNCRESULT_H_

sgw/include/alibabacloud/sgw/model/AddTagsToGatewayRequest.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_ADDTAGSTOGATEWAYREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_ADDTAGSTOGATEWAYREQUEST_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 AddTagsToGatewayRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddTagsToGatewayRequest();
+				~AddTagsToGatewayRequest();
+
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getTags()const;
+				void setTags(const std::string& tags);
+				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 tags_;
+				std::string securityToken_;
+				std::string gatewayId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_ADDTAGSTOGATEWAYREQUEST_H_

sgw/include/alibabacloud/sgw/model/AddTagsToGatewayResult.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SGW_MODEL_ADDTAGSTOGATEWAYRESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_ADDTAGSTOGATEWAYRESULT_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 AddTagsToGatewayResult : public ServiceResult
+			{
+			public:
+
+
+				AddTagsToGatewayResult();
+				explicit AddTagsToGatewayResult(const std::string &payload);
+				~AddTagsToGatewayResult();
+				std::string getMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_ADDTAGSTOGATEWAYRESULT_H_

sgw/include/alibabacloud/sgw/model/CheckActivationKeyRequest.h

@@ -0,0 +1,63 @@
+/*
+ * 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_CHECKACTIVATIONKEYREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_CHECKACTIVATIONKEYREQUEST_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 CheckActivationKeyRequest : public RpcServiceRequest
+			{
+
+			public:
+				CheckActivationKeyRequest();
+				~CheckActivationKeyRequest();
+
+				std::string getCryptKey()const;
+				void setCryptKey(const std::string& cryptKey);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getToken()const;
+				void setToken(const std::string& token);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getCryptText()const;
+				void setCryptText(const std::string& cryptText);
+				std::string getGatewayId()const;
+				void setGatewayId(const std::string& gatewayId);
+
+            private:
+				std::string cryptKey_;
+				std::string accessKeyId_;
+				std::string token_;
+				std::string securityToken_;
+				std::string cryptText_;
+				std::string gatewayId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CHECKACTIVATIONKEYREQUEST_H_

sgw/include/alibabacloud/sgw/model/CheckActivationKeyResult.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SGW_MODEL_CHECKACTIVATIONKEYRESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_CHECKACTIVATIONKEYRESULT_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 CheckActivationKeyResult : public ServiceResult
+			{
+			public:
+
+
+				CheckActivationKeyResult();
+				explicit CheckActivationKeyResult(const std::string &payload);
+				~CheckActivationKeyResult();
+				std::string getMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CHECKACTIVATIONKEYRESULT_H_

sgw/include/alibabacloud/sgw/model/CheckBlockVolumeNameRequest.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_CHECKBLOCKVOLUMENAMEREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_CHECKBLOCKVOLUMENAMEREQUEST_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 CheckBlockVolumeNameRequest : public RpcServiceRequest
+			{
+
+			public:
+				CheckBlockVolumeNameRequest();
+				~CheckBlockVolumeNameRequest();
+
+				std::string getVolumeName()const;
+				void setVolumeName(const std::string& volumeName);
+				std::string getBucketEndpoint()const;
+				void setBucketEndpoint(const std::string& bucketEndpoint);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getBucketName()const;
+				void setBucketName(const std::string& bucketName);
+
+            private:
+				std::string volumeName_;
+				std::string bucketEndpoint_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string bucketName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CHECKBLOCKVOLUMENAMEREQUEST_H_

sgw/include/alibabacloud/sgw/model/CheckBlockVolumeNameResult.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_CHECKBLOCKVOLUMENAMERESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_CHECKBLOCKVOLUMENAMERESULT_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 CheckBlockVolumeNameResult : public ServiceResult
+			{
+			public:
+
+
+				CheckBlockVolumeNameResult();
+				explicit CheckBlockVolumeNameResult(const std::string &payload);
+				~CheckBlockVolumeNameResult();
+				std::string getIsRequireRecovery()const;
+				std::string getMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string isRequireRecovery_;
+				std::string message_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CHECKBLOCKVOLUMENAMERESULT_H_

sgw/include/alibabacloud/sgw/model/CheckGatewayEssdSupportRequest.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_CHECKGATEWAYESSDSUPPORTREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_CHECKGATEWAYESSDSUPPORTREQUEST_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 CheckGatewayEssdSupportRequest : public RpcServiceRequest
+			{
+
+			public:
+				CheckGatewayEssdSupportRequest();
+				~CheckGatewayEssdSupportRequest();
+
+				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_CHECKGATEWAYESSDSUPPORTREQUEST_H_

sgw/include/alibabacloud/sgw/model/CheckGatewayEssdSupportResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SGW_MODEL_CHECKGATEWAYESSDSUPPORTRESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_CHECKGATEWAYESSDSUPPORTRESULT_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 CheckGatewayEssdSupportResult : public ServiceResult
+			{
+			public:
+
+
+				CheckGatewayEssdSupportResult();
+				explicit CheckGatewayEssdSupportResult(const std::string &payload);
+				~CheckGatewayEssdSupportResult();
+				bool getIsSupportEssd()const;
+				std::string getMessage()const;
+				bool getIsServiceAffect()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool isSupportEssd_;
+				std::string message_;
+				bool isServiceAffect_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CHECKGATEWAYESSDSUPPORTRESULT_H_

sgw/include/alibabacloud/sgw/model/CheckMnsServiceRequest.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_CHECKMNSSERVICEREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_CHECKMNSSERVICEREQUEST_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 CheckMnsServiceRequest : public RpcServiceRequest
+			{
+
+			public:
+				CheckMnsServiceRequest();
+				~CheckMnsServiceRequest();
+
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+
+            private:
+				std::string accessKeyId_;
+				std::string securityToken_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CHECKMNSSERVICEREQUEST_H_

sgw/include/alibabacloud/sgw/model/CheckMnsServiceResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SGW_MODEL_CHECKMNSSERVICERESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_CHECKMNSSERVICERESULT_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 CheckMnsServiceResult : public ServiceResult
+			{
+			public:
+
+
+				CheckMnsServiceResult();
+				explicit CheckMnsServiceResult(const std::string &payload);
+				~CheckMnsServiceResult();
+				std::string getMessage()const;
+				bool getIsEnabled()const;
+				std::string getCheckMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				bool isEnabled_;
+				std::string checkMessage_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CHECKMNSSERVICERESULT_H_

sgw/include/alibabacloud/sgw/model/CheckRoleRequest.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_CHECKROLEREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_CHECKROLEREQUEST_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 CheckRoleRequest : public RpcServiceRequest
+			{
+
+			public:
+				CheckRoleRequest();
+				~CheckRoleRequest();
+
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getRoleType()const;
+				void setRoleType(const std::string& roleType);
+
+            private:
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string roleType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CHECKROLEREQUEST_H_

sgw/include/alibabacloud/sgw/model/CheckRoleResult.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SGW_MODEL_CHECKROLERESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_CHECKROLERESULT_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 CheckRoleResult : public ServiceResult
+			{
+			public:
+
+
+				CheckRoleResult();
+				explicit CheckRoleResult(const std::string &payload);
+				~CheckRoleResult();
+				std::string getMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CHECKROLERESULT_H_

sgw/include/alibabacloud/sgw/model/CheckSlrRoleRequest.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_CHECKSLRROLEREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_CHECKSLRROLEREQUEST_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 CheckSlrRoleRequest : public RpcServiceRequest
+			{
+
+			public:
+				CheckSlrRoleRequest();
+				~CheckSlrRoleRequest();
+
+				std::string getRoleName()const;
+				void setRoleName(const std::string& roleName);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				bool getCreateIfNotExist()const;
+				void setCreateIfNotExist(bool createIfNotExist);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+
+            private:
+				std::string roleName_;
+				std::string accessKeyId_;
+				bool createIfNotExist_;
+				std::string securityToken_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CHECKSLRROLEREQUEST_H_

sgw/include/alibabacloud/sgw/model/CheckSlrRoleResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SGW_MODEL_CHECKSLRROLERESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_CHECKSLRROLERESULT_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 CheckSlrRoleResult : public ServiceResult
+			{
+			public:
+
+
+				CheckSlrRoleResult();
+				explicit CheckSlrRoleResult(const std::string &payload);
+				~CheckSlrRoleResult();
+				bool getExist()const;
+				bool getRequireOldWayCheck()const;
+				std::string getMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool exist_;
+				bool requireOldWayCheck_;
+				std::string message_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CHECKSLRROLERESULT_H_

sgw/include/alibabacloud/sgw/model/CheckUpgradeVersionRequest.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_CHECKUPGRADEVERSIONREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_CHECKUPGRADEVERSIONREQUEST_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 CheckUpgradeVersionRequest : public RpcServiceRequest
+			{
+
+			public:
+				CheckUpgradeVersionRequest();
+				~CheckUpgradeVersionRequest();
+
+				std::string getClientUUID()const;
+				void setClientUUID(const std::string& clientUUID);
+				std::string getGatewayVersion()const;
+				void setGatewayVersion(const std::string& gatewayVersion);
+				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 clientUUID_;
+				std::string gatewayVersion_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string gatewayId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CHECKUPGRADEVERSIONREQUEST_H_

sgw/include/alibabacloud/sgw/model/CheckUpgradeVersionResult.h

@@ -0,0 +1,68 @@
+/*
+ * 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_CHECKUPGRADEVERSIONRESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_CHECKUPGRADEVERSIONRESULT_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 CheckUpgradeVersionResult : public ServiceResult
+			{
+			public:
+				struct Patch
+				{
+					std::string internalUrl;
+					std::string url;
+					std::string name;
+					std::string mD5;
+				};
+
+
+				CheckUpgradeVersionResult();
+				explicit CheckUpgradeVersionResult(const std::string &payload);
+				~CheckUpgradeVersionResult();
+				std::string getMessage()const;
+				std::string getLatestVersion()const;
+				std::string getOption()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::vector<Patch> getPatches()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string latestVersion_;
+				std::string option_;
+				std::string code_;
+				bool success_;
+				std::vector<Patch> patches_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CHECKUPGRADEVERSIONRESULT_H_

sgw/include/alibabacloud/sgw/model/CreateCacheRequest.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_CREATECACHEREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_CREATECACHEREQUEST_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 CreateCacheRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateCacheRequest();
+				~CreateCacheRequest();
+
+				long getSizeInGB()const;
+				void setSizeInGB(long sizeInGB);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getCategory()const;
+				void setCategory(const std::string& category);
+				std::string getGatewayId()const;
+				void setGatewayId(const std::string& gatewayId);
+
+            private:
+				long sizeInGB_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string category_;
+				std::string gatewayId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CREATECACHEREQUEST_H_

sgw/include/alibabacloud/sgw/model/CreateCacheResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SGW_MODEL_CREATECACHERESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_CREATECACHERESULT_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 CreateCacheResult : public ServiceResult
+			{
+			public:
+
+
+				CreateCacheResult();
+				explicit CreateCacheResult(const std::string &payload);
+				~CreateCacheResult();
+				std::string getBuyURL()const;
+				std::string getMessage()const;
+				std::string getCacheId()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string buyURL_;
+				std::string message_;
+				std::string cacheId_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CREATECACHERESULT_H_

sgw/include/alibabacloud/sgw/model/CreateExpressSyncRequest.h

@@ -0,0 +1,66 @@
+/*
+ * 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_CREATEEXPRESSSYNCREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_CREATEEXPRESSSYNCREQUEST_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 CreateExpressSyncRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateExpressSyncRequest();
+				~CreateExpressSyncRequest();
+
+				std::string getBucketRegion()const;
+				void setBucketRegion(const std::string& bucketRegion);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getBucketName()const;
+				void setBucketName(const std::string& bucketName);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getBucketPrefix()const;
+				void setBucketPrefix(const std::string& bucketPrefix);
+
+            private:
+				std::string bucketRegion_;
+				std::string description_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string bucketName_;
+				std::string name_;
+				std::string bucketPrefix_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CREATEEXPRESSSYNCREQUEST_H_

sgw/include/alibabacloud/sgw/model/CreateExpressSyncResult.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_CREATEEXPRESSSYNCRESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_CREATEEXPRESSSYNCRESULT_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 CreateExpressSyncResult : public ServiceResult
+			{
+			public:
+
+
+				CreateExpressSyncResult();
+				explicit CreateExpressSyncResult(const std::string &payload);
+				~CreateExpressSyncResult();
+				std::string getMessage()const;
+				std::string getCode()const;
+				std::string getExpressSyncId()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string code_;
+				std::string expressSyncId_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CREATEEXPRESSSYNCRESULT_H_

sgw/include/alibabacloud/sgw/model/CreateGatewayBlockVolumeRequest.h

@@ -0,0 +1,93 @@
+/*
+ * 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_CREATEGATEWAYBLOCKVOLUMEREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYBLOCKVOLUMEREQUEST_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 CreateGatewayBlockVolumeRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateGatewayBlockVolumeRequest();
+				~CreateGatewayBlockVolumeRequest();
+
+				std::string getOssEndpoint()const;
+				void setOssEndpoint(const std::string& ossEndpoint);
+				bool getRecovery()const;
+				void setRecovery(bool recovery);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				int getChunkSize()const;
+				void setChunkSize(int chunkSize);
+				std::string getGatewayId()const;
+				void setGatewayId(const std::string& gatewayId);
+				std::string getVolumeProtocol()const;
+				void setVolumeProtocol(const std::string& volumeProtocol);
+				bool getChapEnabled()const;
+				void setChapEnabled(bool chapEnabled);
+				std::string getCacheMode()const;
+				void setCacheMode(const std::string& cacheMode);
+				std::string getLocalFilePath()const;
+				void setLocalFilePath(const std::string& localFilePath);
+				bool getOssBucketSsl()const;
+				void setOssBucketSsl(bool ossBucketSsl);
+				long getSize()const;
+				void setSize(long size);
+				std::string getChapInUser()const;
+				void setChapInUser(const std::string& chapInUser);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getOssBucketName()const;
+				void setOssBucketName(const std::string& ossBucketName);
+				std::string getChapInPassword()const;
+				void setChapInPassword(const std::string& chapInPassword);
+
+            private:
+				std::string ossEndpoint_;
+				bool recovery_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				int chunkSize_;
+				std::string gatewayId_;
+				std::string volumeProtocol_;
+				bool chapEnabled_;
+				std::string cacheMode_;
+				std::string localFilePath_;
+				bool ossBucketSsl_;
+				long size_;
+				std::string chapInUser_;
+				std::string name_;
+				std::string ossBucketName_;
+				std::string chapInPassword_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYBLOCKVOLUMEREQUEST_H_

sgw/include/alibabacloud/sgw/model/CreateGatewayBlockVolumeResult.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_CREATEGATEWAYBLOCKVOLUMERESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYBLOCKVOLUMERESULT_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 CreateGatewayBlockVolumeResult : public ServiceResult
+			{
+			public:
+
+
+				CreateGatewayBlockVolumeResult();
+				explicit CreateGatewayBlockVolumeResult(const std::string &payload);
+				~CreateGatewayBlockVolumeResult();
+				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_CREATEGATEWAYBLOCKVOLUMERESULT_H_

sgw/include/alibabacloud/sgw/model/CreateGatewayCacheDiskRequest.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_CREATEGATEWAYCACHEDISKREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYCACHEDISKREQUEST_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 CreateGatewayCacheDiskRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateGatewayCacheDiskRequest();
+				~CreateGatewayCacheDiskRequest();
+
+				long getCacheDiskSizeInGB()const;
+				void setCacheDiskSizeInGB(long cacheDiskSizeInGB);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getCacheDiskCategory()const;
+				void setCacheDiskCategory(const std::string& cacheDiskCategory);
+				std::string getGatewayId()const;
+				void setGatewayId(const std::string& gatewayId);
+
+            private:
+				long cacheDiskSizeInGB_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string cacheDiskCategory_;
+				std::string gatewayId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYCACHEDISKREQUEST_H_

sgw/include/alibabacloud/sgw/model/CreateGatewayCacheDiskResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYCACHEDISKRESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYCACHEDISKRESULT_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 CreateGatewayCacheDiskResult : public ServiceResult
+			{
+			public:
+
+
+				CreateGatewayCacheDiskResult();
+				explicit CreateGatewayCacheDiskResult(const std::string &payload);
+				~CreateGatewayCacheDiskResult();
+				std::string getBuyURL()const;
+				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 buyURL_;
+				std::string taskId_;
+				std::string message_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYCACHEDISKRESULT_H_

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

@@ -0,0 +1,165 @@
+/*
+ * 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_CREATEGATEWAYFILESHAREREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYFILESHAREREQUEST_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 CreateGatewayFileShareRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateGatewayFileShareRequest();
+				~CreateGatewayFileShareRequest();
+
+				bool getInPlace()const;
+				void setInPlace(bool inPlace);
+				std::string getOssEndpoint()const;
+				void setOssEndpoint(const std::string& ossEndpoint);
+				std::string getReadWriteClientList()const;
+				void setReadWriteClientList(const std::string& readWriteClientList);
+				int getBackendLimit()const;
+				void setBackendLimit(int backendLimit);
+				std::string getSquash()const;
+				void setSquash(const std::string& squash);
+				std::string getReadOnlyClientList()const;
+				void setReadOnlyClientList(const std::string& readOnlyClientList);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				long getKmsRotatePeriod()const;
+				void setKmsRotatePeriod(long kmsRotatePeriod);
+				bool getRemoteSyncDownload()const;
+				void setRemoteSyncDownload(bool remoteSyncDownload);
+				std::string getShareProtocol()const;
+				void setShareProtocol(const std::string& shareProtocol);
+				bool getNfsV4Optimization()const;
+				void setNfsV4Optimization(bool nfsV4Optimization);
+				bool getAccessBasedEnumeration()const;
+				void setAccessBasedEnumeration(bool accessBasedEnumeration);
+				std::string getGatewayId()const;
+				void setGatewayId(const std::string& gatewayId);
+				bool getSupportArchive()const;
+				void setSupportArchive(bool supportArchive);
+				std::string getCacheMode()const;
+				void setCacheMode(const std::string& cacheMode);
+				std::string getLocalFilePath()const;
+				void setLocalFilePath(const std::string& localFilePath);
+				std::string getPartialSyncPaths()const;
+				void setPartialSyncPaths(const std::string& partialSyncPaths);
+				int getDownloadLimit()const;
+				void setDownloadLimit(int downloadLimit);
+				std::string getReadOnlyUserList()const;
+				void setReadOnlyUserList(const std::string& readOnlyUserList);
+				bool getFastReclaim()const;
+				void setFastReclaim(bool fastReclaim);
+				bool getWindowsAcl()const;
+				void setWindowsAcl(bool windowsAcl);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getOssBucketName()const;
+				void setOssBucketName(const std::string& ossBucketName);
+				bool getTransferAcceleration()const;
+				void setTransferAcceleration(bool transferAcceleration);
+				std::string getClientSideCmk()const;
+				void setClientSideCmk(const std::string& clientSideCmk);
+				std::string getPathPrefix()const;
+				void setPathPrefix(const std::string& pathPrefix);
+				bool getBrowsable()const;
+				void setBrowsable(bool browsable);
+				std::string getReadWriteUserList()const;
+				void setReadWriteUserList(const std::string& readWriteUserList);
+				int getPollingInterval()const;
+				void setPollingInterval(int pollingInterval);
+				bool getEnabled()const;
+				void setEnabled(bool enabled);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getServerSideCmk()const;
+				void setServerSideCmk(const std::string& serverSideCmk);
+				bool getServerSideEncryption()const;
+				void setServerSideEncryption(bool serverSideEncryption);
+				bool getIgnoreDelete()const;
+				void setIgnoreDelete(bool ignoreDelete);
+				long getLagPeriod()const;
+				void setLagPeriod(long lagPeriod);
+				bool getDirectIO()const;
+				void setDirectIO(bool directIO);
+				bool getClientSideEncryption()const;
+				void setClientSideEncryption(bool clientSideEncryption);
+				bool getOssBucketSsl()const;
+				void setOssBucketSsl(bool ossBucketSsl);
+				bool getRemoteSync()const;
+				void setRemoteSync(bool remoteSync);
+				int getFrontendLimit()const;
+				void setFrontendLimit(int frontendLimit);
+
+            private:
+				bool inPlace_;
+				std::string ossEndpoint_;
+				std::string readWriteClientList_;
+				int backendLimit_;
+				std::string squash_;
+				std::string readOnlyClientList_;
+				std::string securityToken_;
+				long kmsRotatePeriod_;
+				bool remoteSyncDownload_;
+				std::string shareProtocol_;
+				bool nfsV4Optimization_;
+				bool accessBasedEnumeration_;
+				std::string gatewayId_;
+				bool supportArchive_;
+				std::string cacheMode_;
+				std::string localFilePath_;
+				std::string partialSyncPaths_;
+				int downloadLimit_;
+				std::string readOnlyUserList_;
+				bool fastReclaim_;
+				bool windowsAcl_;
+				std::string name_;
+				std::string ossBucketName_;
+				bool transferAcceleration_;
+				std::string clientSideCmk_;
+				std::string pathPrefix_;
+				bool browsable_;
+				std::string readWriteUserList_;
+				int pollingInterval_;
+				bool enabled_;
+				std::string accessKeyId_;
+				std::string serverSideCmk_;
+				bool serverSideEncryption_;
+				bool ignoreDelete_;
+				long lagPeriod_;
+				bool directIO_;
+				bool clientSideEncryption_;
+				bool ossBucketSsl_;
+				bool remoteSync_;
+				int frontendLimit_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYFILESHAREREQUEST_H_

sgw/include/alibabacloud/sgw/model/CreateGatewayFileShareResult.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_CREATEGATEWAYFILESHARERESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYFILESHARERESULT_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 CreateGatewayFileShareResult : public ServiceResult
+			{
+			public:
+
+
+				CreateGatewayFileShareResult();
+				explicit CreateGatewayFileShareResult(const std::string &payload);
+				~CreateGatewayFileShareResult();
+				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_CREATEGATEWAYFILESHARERESULT_H_

sgw/include/alibabacloud/sgw/model/CreateGatewayLoggingRequest.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_CREATEGATEWAYLOGGINGREQUEST_H_
+#define ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYLOGGINGREQUEST_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 CreateGatewayLoggingRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateGatewayLoggingRequest();
+				~CreateGatewayLoggingRequest();
+
+				std::string getSlsLogstore()const;
+				void setSlsLogstore(const std::string& slsLogstore);
+				std::string getSlsProject()const;
+				void setSlsProject(const std::string& slsProject);
+				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 slsLogstore_;
+				std::string slsProject_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string gatewayId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYLOGGINGREQUEST_H_

sgw/include/alibabacloud/sgw/model/CreateGatewayLoggingResult.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYLOGGINGRESULT_H_
+#define ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYLOGGINGRESULT_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 CreateGatewayLoggingResult : public ServiceResult
+			{
+			public:
+
+
+				CreateGatewayLoggingResult();
+				explicit CreateGatewayLoggingResult(const std::string &payload);
+				~CreateGatewayLoggingResult();
+				std::string getMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYLOGGINGRESULT_H_