Added Global Distribute Cache OpenAPIs.

CHANGELOG

@@ -1,3 +1,19 @@
+2020-08-20 Version: 1.36.601
+- Added Global Distribute Cache OpenAPIs.
+- Added direct connection OpenAPIs.
+
+2020-08-19 Version: 1.36.600
+- Add DescribeLiveDomainCertificateInfo.
+
+2020-08-19 Version: 1.36.599
+- Generated 2020-08-01 for `SmartHosting`.
+
+2020-08-18 Version: 1.36.598
+- Support for describe hbaseue multi-zone model.
+
+2020-08-18 Version: 1.36.597
+- Support session query operations.
+
 2020-08-18 Version: 1.36.596
 - Public beta version.
 - Add Api Overseas.

VERSION

@@ -1 +1 @@
-1.36.596
+1.36.601

hbase/CMakeLists.txt

@@ -35,6 +35,8 @@ set(hbase_public_header_model
 	include/alibabacloud/hbase/model/CreateMultiZoneClusterResult.h
 	include/alibabacloud/hbase/model/CreateRestorePlanRequest.h
 	include/alibabacloud/hbase/model/CreateRestorePlanResult.h
+	include/alibabacloud/hbase/model/DeleteHBaseHaDBRequest.h
+	include/alibabacloud/hbase/model/DeleteHBaseHaDBResult.h
 	include/alibabacloud/hbase/model/DeleteHbaseHaSlbRequest.h
 	include/alibabacloud/hbase/model/DeleteHbaseHaSlbResult.h
 	include/alibabacloud/hbase/model/DeleteInstanceRequest.h
@@ -67,6 +69,12 @@ set(hbase_public_header_model
 	include/alibabacloud/hbase/model/DescribeInstancesResult.h
 	include/alibabacloud/hbase/model/DescribeIpWhitelistRequest.h
 	include/alibabacloud/hbase/model/DescribeIpWhitelistResult.h
+	include/alibabacloud/hbase/model/DescribeMultiZoneAvailableRegionsRequest.h
+	include/alibabacloud/hbase/model/DescribeMultiZoneAvailableRegionsResult.h
+	include/alibabacloud/hbase/model/DescribeMultiZoneAvailableResourceRequest.h
+	include/alibabacloud/hbase/model/DescribeMultiZoneAvailableResourceResult.h
+	include/alibabacloud/hbase/model/DescribeMultiZoneClusterRequest.h
+	include/alibabacloud/hbase/model/DescribeMultiZoneClusterResult.h
 	include/alibabacloud/hbase/model/DescribeRecoverableTimeRangeRequest.h
 	include/alibabacloud/hbase/model/DescribeRecoverableTimeRangeResult.h
 	include/alibabacloud/hbase/model/DescribeRegionsRequest.h
@@ -87,6 +95,8 @@ set(hbase_public_header_model
 	include/alibabacloud/hbase/model/EnableHBaseueBackupResult.h
 	include/alibabacloud/hbase/model/EnableHBaseueModuleRequest.h
 	include/alibabacloud/hbase/model/EnableHBaseueModuleResult.h
+	include/alibabacloud/hbase/model/EvaluateMultiZoneResourceRequest.h
+	include/alibabacloud/hbase/model/EvaluateMultiZoneResourceResult.h
 	include/alibabacloud/hbase/model/ListTagResourcesRequest.h
 	include/alibabacloud/hbase/model/ListTagResourcesResult.h
 	include/alibabacloud/hbase/model/ListTagsRequest.h
@@ -125,6 +135,8 @@ set(hbase_public_header_model
 	include/alibabacloud/hbase/model/TagResourcesResult.h
 	include/alibabacloud/hbase/model/UnTagResourcesRequest.h
 	include/alibabacloud/hbase/model/UnTagResourcesResult.h
+	include/alibabacloud/hbase/model/UpgradeMultiZoneClusterRequest.h
+	include/alibabacloud/hbase/model/UpgradeMultiZoneClusterResult.h
 	include/alibabacloud/hbase/model/XpackRelateDBRequest.h
 	include/alibabacloud/hbase/model/XpackRelateDBResult.h )
 
@@ -144,6 +156,8 @@ set(hbase_src
 	src/model/CreateMultiZoneClusterResult.cc
 	src/model/CreateRestorePlanRequest.cc
 	src/model/CreateRestorePlanResult.cc
+	src/model/DeleteHBaseHaDBRequest.cc
+	src/model/DeleteHBaseHaDBResult.cc
 	src/model/DeleteHbaseHaSlbRequest.cc
 	src/model/DeleteHbaseHaSlbResult.cc
 	src/model/DeleteInstanceRequest.cc
@@ -176,6 +190,12 @@ set(hbase_src
 	src/model/DescribeInstancesResult.cc
 	src/model/DescribeIpWhitelistRequest.cc
 	src/model/DescribeIpWhitelistResult.cc
+	src/model/DescribeMultiZoneAvailableRegionsRequest.cc
+	src/model/DescribeMultiZoneAvailableRegionsResult.cc
+	src/model/DescribeMultiZoneAvailableResourceRequest.cc
+	src/model/DescribeMultiZoneAvailableResourceResult.cc
+	src/model/DescribeMultiZoneClusterRequest.cc
+	src/model/DescribeMultiZoneClusterResult.cc
 	src/model/DescribeRecoverableTimeRangeRequest.cc
 	src/model/DescribeRecoverableTimeRangeResult.cc
 	src/model/DescribeRegionsRequest.cc
@@ -196,6 +216,8 @@ set(hbase_src
 	src/model/EnableHBaseueBackupResult.cc
 	src/model/EnableHBaseueModuleRequest.cc
 	src/model/EnableHBaseueModuleResult.cc
+	src/model/EvaluateMultiZoneResourceRequest.cc
+	src/model/EvaluateMultiZoneResourceResult.cc
 	src/model/ListTagResourcesRequest.cc
 	src/model/ListTagResourcesResult.cc
 	src/model/ListTagsRequest.cc
@@ -234,6 +256,8 @@ set(hbase_src
 	src/model/TagResourcesResult.cc
 	src/model/UnTagResourcesRequest.cc
 	src/model/UnTagResourcesResult.cc
+	src/model/UpgradeMultiZoneClusterRequest.cc
+	src/model/UpgradeMultiZoneClusterResult.cc
 	src/model/XpackRelateDBRequest.cc
 	src/model/XpackRelateDBResult.cc )
 

hbase/include/alibabacloud/hbase/HBaseClient.h

@@ -36,6 +36,8 @@
 #include "model/CreateMultiZoneClusterResult.h"
 #include "model/CreateRestorePlanRequest.h"
 #include "model/CreateRestorePlanResult.h"
+#include "model/DeleteHBaseHaDBRequest.h"
+#include "model/DeleteHBaseHaDBResult.h"
 #include "model/DeleteHbaseHaSlbRequest.h"
 #include "model/DeleteHbaseHaSlbResult.h"
 #include "model/DeleteInstanceRequest.h"
@@ -68,6 +70,12 @@
 #include "model/DescribeInstancesResult.h"
 #include "model/DescribeIpWhitelistRequest.h"
 #include "model/DescribeIpWhitelistResult.h"
+#include "model/DescribeMultiZoneAvailableRegionsRequest.h"
+#include "model/DescribeMultiZoneAvailableRegionsResult.h"
+#include "model/DescribeMultiZoneAvailableResourceRequest.h"
+#include "model/DescribeMultiZoneAvailableResourceResult.h"
+#include "model/DescribeMultiZoneClusterRequest.h"
+#include "model/DescribeMultiZoneClusterResult.h"
 #include "model/DescribeRecoverableTimeRangeRequest.h"
 #include "model/DescribeRecoverableTimeRangeResult.h"
 #include "model/DescribeRegionsRequest.h"
@@ -88,6 +96,8 @@
 #include "model/EnableHBaseueBackupResult.h"
 #include "model/EnableHBaseueModuleRequest.h"
 #include "model/EnableHBaseueModuleResult.h"
+#include "model/EvaluateMultiZoneResourceRequest.h"
+#include "model/EvaluateMultiZoneResourceResult.h"
 #include "model/ListTagResourcesRequest.h"
 #include "model/ListTagResourcesResult.h"
 #include "model/ListTagsRequest.h"
@@ -126,6 +136,8 @@
 #include "model/TagResourcesResult.h"
 #include "model/UnTagResourcesRequest.h"
 #include "model/UnTagResourcesResult.h"
+#include "model/UpgradeMultiZoneClusterRequest.h"
+#include "model/UpgradeMultiZoneClusterResult.h"
 #include "model/XpackRelateDBRequest.h"
 #include "model/XpackRelateDBResult.h"
 
@@ -158,6 +170,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateRestorePlanResult> CreateRestorePlanOutcome;
 			typedef std::future<CreateRestorePlanOutcome> CreateRestorePlanOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::CreateRestorePlanRequest&, const CreateRestorePlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRestorePlanAsyncHandler;
+			typedef Outcome<Error, Model::DeleteHBaseHaDBResult> DeleteHBaseHaDBOutcome;
+			typedef std::future<DeleteHBaseHaDBOutcome> DeleteHBaseHaDBOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DeleteHBaseHaDBRequest&, const DeleteHBaseHaDBOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteHBaseHaDBAsyncHandler;
 			typedef Outcome<Error, Model::DeleteHbaseHaSlbResult> DeleteHbaseHaSlbOutcome;
 			typedef std::future<DeleteHbaseHaSlbOutcome> DeleteHbaseHaSlbOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::DeleteHbaseHaSlbRequest&, const DeleteHbaseHaSlbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteHbaseHaSlbAsyncHandler;
@@ -206,6 +221,15 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeIpWhitelistResult> DescribeIpWhitelistOutcome;
 			typedef std::future<DescribeIpWhitelistOutcome> DescribeIpWhitelistOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::DescribeIpWhitelistRequest&, const DescribeIpWhitelistOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeIpWhitelistAsyncHandler;
+			typedef Outcome<Error, Model::DescribeMultiZoneAvailableRegionsResult> DescribeMultiZoneAvailableRegionsOutcome;
+			typedef std::future<DescribeMultiZoneAvailableRegionsOutcome> DescribeMultiZoneAvailableRegionsOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DescribeMultiZoneAvailableRegionsRequest&, const DescribeMultiZoneAvailableRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMultiZoneAvailableRegionsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeMultiZoneAvailableResourceResult> DescribeMultiZoneAvailableResourceOutcome;
+			typedef std::future<DescribeMultiZoneAvailableResourceOutcome> DescribeMultiZoneAvailableResourceOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DescribeMultiZoneAvailableResourceRequest&, const DescribeMultiZoneAvailableResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMultiZoneAvailableResourceAsyncHandler;
+			typedef Outcome<Error, Model::DescribeMultiZoneClusterResult> DescribeMultiZoneClusterOutcome;
+			typedef std::future<DescribeMultiZoneClusterOutcome> DescribeMultiZoneClusterOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DescribeMultiZoneClusterRequest&, const DescribeMultiZoneClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMultiZoneClusterAsyncHandler;
 			typedef Outcome<Error, Model::DescribeRecoverableTimeRangeResult> DescribeRecoverableTimeRangeOutcome;
 			typedef std::future<DescribeRecoverableTimeRangeOutcome> DescribeRecoverableTimeRangeOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::DescribeRecoverableTimeRangeRequest&, const DescribeRecoverableTimeRangeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRecoverableTimeRangeAsyncHandler;
@@ -236,6 +260,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::EnableHBaseueModuleResult> EnableHBaseueModuleOutcome;
 			typedef std::future<EnableHBaseueModuleOutcome> EnableHBaseueModuleOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::EnableHBaseueModuleRequest&, const EnableHBaseueModuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableHBaseueModuleAsyncHandler;
+			typedef Outcome<Error, Model::EvaluateMultiZoneResourceResult> EvaluateMultiZoneResourceOutcome;
+			typedef std::future<EvaluateMultiZoneResourceOutcome> EvaluateMultiZoneResourceOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::EvaluateMultiZoneResourceRequest&, const EvaluateMultiZoneResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EvaluateMultiZoneResourceAsyncHandler;
 			typedef Outcome<Error, Model::ListTagResourcesResult> ListTagResourcesOutcome;
 			typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
@@ -293,6 +320,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UnTagResourcesResult> UnTagResourcesOutcome;
 			typedef std::future<UnTagResourcesOutcome> UnTagResourcesOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::UnTagResourcesRequest&, const UnTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnTagResourcesAsyncHandler;
+			typedef Outcome<Error, Model::UpgradeMultiZoneClusterResult> UpgradeMultiZoneClusterOutcome;
+			typedef std::future<UpgradeMultiZoneClusterOutcome> UpgradeMultiZoneClusterOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::UpgradeMultiZoneClusterRequest&, const UpgradeMultiZoneClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpgradeMultiZoneClusterAsyncHandler;
 			typedef Outcome<Error, Model::XpackRelateDBResult> XpackRelateDBOutcome;
 			typedef std::future<XpackRelateDBOutcome> XpackRelateDBOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::XpackRelateDBRequest&, const XpackRelateDBOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> XpackRelateDBAsyncHandler;
@@ -322,6 +352,9 @@ namespace AlibabaCloud
 			CreateRestorePlanOutcome createRestorePlan(const Model::CreateRestorePlanRequest &request)const;
 			void createRestorePlanAsync(const Model::CreateRestorePlanRequest& request, const CreateRestorePlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateRestorePlanOutcomeCallable createRestorePlanCallable(const Model::CreateRestorePlanRequest& request) const;
+			DeleteHBaseHaDBOutcome deleteHBaseHaDB(const Model::DeleteHBaseHaDBRequest &request)const;
+			void deleteHBaseHaDBAsync(const Model::DeleteHBaseHaDBRequest& request, const DeleteHBaseHaDBAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteHBaseHaDBOutcomeCallable deleteHBaseHaDBCallable(const Model::DeleteHBaseHaDBRequest& request) const;
 			DeleteHbaseHaSlbOutcome deleteHbaseHaSlb(const Model::DeleteHbaseHaSlbRequest &request)const;
 			void deleteHbaseHaSlbAsync(const Model::DeleteHbaseHaSlbRequest& request, const DeleteHbaseHaSlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteHbaseHaSlbOutcomeCallable deleteHbaseHaSlbCallable(const Model::DeleteHbaseHaSlbRequest& request) const;
@@ -370,6 +403,15 @@ namespace AlibabaCloud
 			DescribeIpWhitelistOutcome describeIpWhitelist(const Model::DescribeIpWhitelistRequest &request)const;
 			void describeIpWhitelistAsync(const Model::DescribeIpWhitelistRequest& request, const DescribeIpWhitelistAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeIpWhitelistOutcomeCallable describeIpWhitelistCallable(const Model::DescribeIpWhitelistRequest& request) const;
+			DescribeMultiZoneAvailableRegionsOutcome describeMultiZoneAvailableRegions(const Model::DescribeMultiZoneAvailableRegionsRequest &request)const;
+			void describeMultiZoneAvailableRegionsAsync(const Model::DescribeMultiZoneAvailableRegionsRequest& request, const DescribeMultiZoneAvailableRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeMultiZoneAvailableRegionsOutcomeCallable describeMultiZoneAvailableRegionsCallable(const Model::DescribeMultiZoneAvailableRegionsRequest& request) const;
+			DescribeMultiZoneAvailableResourceOutcome describeMultiZoneAvailableResource(const Model::DescribeMultiZoneAvailableResourceRequest &request)const;
+			void describeMultiZoneAvailableResourceAsync(const Model::DescribeMultiZoneAvailableResourceRequest& request, const DescribeMultiZoneAvailableResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeMultiZoneAvailableResourceOutcomeCallable describeMultiZoneAvailableResourceCallable(const Model::DescribeMultiZoneAvailableResourceRequest& request) const;
+			DescribeMultiZoneClusterOutcome describeMultiZoneCluster(const Model::DescribeMultiZoneClusterRequest &request)const;
+			void describeMultiZoneClusterAsync(const Model::DescribeMultiZoneClusterRequest& request, const DescribeMultiZoneClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeMultiZoneClusterOutcomeCallable describeMultiZoneClusterCallable(const Model::DescribeMultiZoneClusterRequest& request) const;
 			DescribeRecoverableTimeRangeOutcome describeRecoverableTimeRange(const Model::DescribeRecoverableTimeRangeRequest &request)const;
 			void describeRecoverableTimeRangeAsync(const Model::DescribeRecoverableTimeRangeRequest& request, const DescribeRecoverableTimeRangeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeRecoverableTimeRangeOutcomeCallable describeRecoverableTimeRangeCallable(const Model::DescribeRecoverableTimeRangeRequest& request) const;
@@ -400,6 +442,9 @@ namespace AlibabaCloud
 			EnableHBaseueModuleOutcome enableHBaseueModule(const Model::EnableHBaseueModuleRequest &request)const;
 			void enableHBaseueModuleAsync(const Model::EnableHBaseueModuleRequest& request, const EnableHBaseueModuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			EnableHBaseueModuleOutcomeCallable enableHBaseueModuleCallable(const Model::EnableHBaseueModuleRequest& request) const;
+			EvaluateMultiZoneResourceOutcome evaluateMultiZoneResource(const Model::EvaluateMultiZoneResourceRequest &request)const;
+			void evaluateMultiZoneResourceAsync(const Model::EvaluateMultiZoneResourceRequest& request, const EvaluateMultiZoneResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EvaluateMultiZoneResourceOutcomeCallable evaluateMultiZoneResourceCallable(const Model::EvaluateMultiZoneResourceRequest& 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;
@@ -457,6 +502,9 @@ namespace AlibabaCloud
 			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;
+			UpgradeMultiZoneClusterOutcome upgradeMultiZoneCluster(const Model::UpgradeMultiZoneClusterRequest &request)const;
+			void upgradeMultiZoneClusterAsync(const Model::UpgradeMultiZoneClusterRequest& request, const UpgradeMultiZoneClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpgradeMultiZoneClusterOutcomeCallable upgradeMultiZoneClusterCallable(const Model::UpgradeMultiZoneClusterRequest& request) const;
 			XpackRelateDBOutcome xpackRelateDB(const Model::XpackRelateDBRequest &request)const;
 			void xpackRelateDBAsync(const Model::XpackRelateDBRequest& request, const XpackRelateDBAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			XpackRelateDBOutcomeCallable xpackRelateDBCallable(const Model::XpackRelateDBRequest& request) const;

hbase/include/alibabacloud/hbase/model/DeleteHBaseHaDBRequest.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_HBASE_MODEL_DELETEHBASEHADBREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_DELETEHBASEHADBREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DeleteHBaseHaDBRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteHBaseHaDBRequest();
+				~DeleteHBaseHaDBRequest();
+
+				std::string getHaId()const;
+				void setHaId(const std::string& haId);
+				std::string getBdsId()const;
+				void setBdsId(const std::string& bdsId);
+
+            private:
+				std::string haId_;
+				std::string bdsId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DELETEHBASEHADBREQUEST_H_

hbase/include/alibabacloud/hbase/model/DeleteHBaseHaDBResult.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_HBASE_MODEL_DELETEHBASEHADBRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_DELETEHBASEHADBRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DeleteHBaseHaDBResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteHBaseHaDBResult();
+				explicit DeleteHBaseHaDBResult(const std::string &payload);
+				~DeleteHBaseHaDBResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DELETEHBASEHADBRESULT_H_

hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableRegionsRequest.h

@@ -0,0 +1,48 @@
+/*
+ * 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_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLEREGIONSREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLEREGIONSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DescribeMultiZoneAvailableRegionsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeMultiZoneAvailableRegionsRequest();
+				~DescribeMultiZoneAvailableRegionsRequest();
+
+				std::string getAcceptLanguage()const;
+				void setAcceptLanguage(const std::string& acceptLanguage);
+
+            private:
+				std::string acceptLanguage_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLEREGIONSREQUEST_H_

hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableRegionsResult.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_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLEREGIONSRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLEREGIONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DescribeMultiZoneAvailableRegionsResult : public ServiceResult
+			{
+			public:
+				struct Region
+				{
+					struct AvailableCombine
+					{
+						std::string id;
+						std::vector<std::string> zones;
+					};
+					std::string regionId;
+					std::vector<Region::AvailableCombine> availableCombines;
+					std::string regionEndpoint;
+					std::string localName;
+				};
+
+
+				DescribeMultiZoneAvailableRegionsResult();
+				explicit DescribeMultiZoneAvailableRegionsResult(const std::string &payload);
+				~DescribeMultiZoneAvailableRegionsResult();
+				std::vector<Region> getRegions()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Region> regions_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLEREGIONSRESULT_H_

hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableResourceRequest.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_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLERESOURCEREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLERESOURCEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DescribeMultiZoneAvailableResourceRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeMultiZoneAvailableResourceRequest();
+				~DescribeMultiZoneAvailableResourceRequest();
+
+				std::string getZoneCombination()const;
+				void setZoneCombination(const std::string& zoneCombination);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getChargeType()const;
+				void setChargeType(const std::string& chargeType);
+
+            private:
+				std::string zoneCombination_;
+				std::string regionId_;
+				std::string chargeType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLERESOURCEREQUEST_H_

hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableResourceResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLERESOURCERESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLERESOURCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DescribeMultiZoneAvailableResourceResult : public ServiceResult
+			{
+			public:
+				struct AvailableZone
+				{
+					struct MasterResource
+					{
+						struct InstanceTypeDetail
+						{
+							int mem;
+							int cpu;
+						};
+						InstanceTypeDetail instanceTypeDetail;
+						std::string instanceType;
+					};
+					struct SupportedEngine
+					{
+						struct SupportedEngineVersion
+						{
+							struct SupportedCategoriesItem
+							{
+								struct SupportedStorageType
+								{
+									struct CoreResource
+									{
+										struct DBInstanceStorageRange
+										{
+											int minSize;
+											int stepSize;
+											int maxSize;
+										};
+										struct InstanceTypeDetail1
+										{
+											int mem;
+											int cpu;
+										};
+										InstanceTypeDetail1 instanceTypeDetail1;
+										DBInstanceStorageRange dBInstanceStorageRange;
+										std::string instanceType;
+										int maxCoreCount;
+									};
+									std::string storageType;
+									std::vector<SupportedStorageType::CoreResource> coreResources;
+								};
+								std::string category;
+								std::vector<SupportedCategoriesItem::SupportedStorageType> supportedStorageTypes;
+							};
+							std::string version;
+							std::vector<SupportedEngineVersion::SupportedCategoriesItem> supportedCategories;
+						};
+						std::vector<SupportedEngine::SupportedEngineVersion> supportedEngineVersions;
+						std::string engine;
+					};
+					std::vector<AvailableZone::MasterResource> masterResources;
+					std::string zoneCombination;
+					std::vector<AvailableZone::SupportedEngine> supportedEngines;
+					std::string regionId;
+				};
+
+
+				DescribeMultiZoneAvailableResourceResult();
+				explicit DescribeMultiZoneAvailableResourceResult(const std::string &payload);
+				~DescribeMultiZoneAvailableResourceResult();
+				std::vector<AvailableZone> getAvailableZones()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<AvailableZone> availableZones_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLERESOURCERESULT_H_

hbase/include/alibabacloud/hbase/model/DescribeMultiZoneClusterRequest.h

@@ -0,0 +1,48 @@
+/*
+ * 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_HBASE_MODEL_DESCRIBEMULTIZONECLUSTERREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONECLUSTERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DescribeMultiZoneClusterRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeMultiZoneClusterRequest();
+				~DescribeMultiZoneClusterRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+
+            private:
+				std::string clusterId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONECLUSTERREQUEST_H_

hbase/include/alibabacloud/hbase/model/DescribeMultiZoneClusterResult.h

@@ -0,0 +1,154 @@
+/*
+ * 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_HBASE_MODEL_DESCRIBEMULTIZONECLUSTERRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONECLUSTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DescribeMultiZoneClusterResult : public ServiceResult
+			{
+			public:
+				struct MultiZoneInstanceModel
+				{
+					std::string status;
+					std::string role;
+					bool isLatestVersion;
+					std::string minorVersion;
+					std::string insName;
+				};
+				struct Tag
+				{
+					std::string value;
+					std::string key;
+				};
+
+
+				DescribeMultiZoneClusterResult();
+				explicit DescribeMultiZoneClusterResult(const std::string &payload);
+				~DescribeMultiZoneClusterResult();
+				std::string getModuleStackVersion()const;
+				std::string getStandbyZoneId()const;
+				std::string getCreatedTime()const;
+				std::string getMasterInstanceType()const;
+				std::string getPrimaryVSwitchIds()const;
+				bool getIsDeletionProtection()const;
+				std::string getLogDiskCount()const;
+				int getLogDiskSize()const;
+				int getModuleId()const;
+				std::string getArbiterVSwitchIds()const;
+				std::string getMaintainEndTime()const;
+				std::string getStandbyVSwitchIds()const;
+				std::string getNetworkType()const;
+				std::string getCoreInstanceType()const;
+				std::string getClusterName()const;
+				std::string getMasterDiskType()const;
+				std::vector<Tag> getTags()const;
+				std::string getEngine()const;
+				std::string getMaintainStartTime()const;
+				std::string getArbiterZoneId()const;
+				std::string getMajorVersion()const;
+				std::string getCoreDiskCount()const;
+				std::string getParentId()const;
+				std::string getStatus()const;
+				std::vector<MultiZoneInstanceModel> getMultiZoneInstanceModels()const;
+				std::string getExpireTimeUTC()const;
+				int getMasterDiskSize()const;
+				std::string getPrimaryZoneId()const;
+				std::string getMultiZoneCombination()const;
+				std::string getClusterId()const;
+				std::string getInstanceId()const;
+				int getCoreNodeCount()const;
+				std::string getCreatedTimeUTC()const;
+				int getDuration()const;
+				std::string getLogInstanceType()const;
+				std::string getPayType()const;
+				std::string getInstanceName()const;
+				int getMasterNodeCount()const;
+				bool getAutoRenewal()const;
+				std::string getVpcId()const;
+				std::string getCoreDiskType()const;
+				int getLogNodeCount()const;
+				std::string getLogDiskType()const;
+				std::string getRegionId()const;
+				std::string getExpireTime()const;
+				int getCoreDiskSize()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string moduleStackVersion_;
+				std::string standbyZoneId_;
+				std::string createdTime_;
+				std::string masterInstanceType_;
+				std::string primaryVSwitchIds_;
+				bool isDeletionProtection_;
+				std::string logDiskCount_;
+				int logDiskSize_;
+				int moduleId_;
+				std::string arbiterVSwitchIds_;
+				std::string maintainEndTime_;
+				std::string standbyVSwitchIds_;
+				std::string networkType_;
+				std::string coreInstanceType_;
+				std::string clusterName_;
+				std::string masterDiskType_;
+				std::vector<Tag> tags_;
+				std::string engine_;
+				std::string maintainStartTime_;
+				std::string arbiterZoneId_;
+				std::string majorVersion_;
+				std::string coreDiskCount_;
+				std::string parentId_;
+				std::string status_;
+				std::vector<MultiZoneInstanceModel> multiZoneInstanceModels_;
+				std::string expireTimeUTC_;
+				int masterDiskSize_;
+				std::string primaryZoneId_;
+				std::string multiZoneCombination_;
+				std::string clusterId_;
+				std::string instanceId_;
+				int coreNodeCount_;
+				std::string createdTimeUTC_;
+				int duration_;
+				std::string logInstanceType_;
+				std::string payType_;
+				std::string instanceName_;
+				int masterNodeCount_;
+				bool autoRenewal_;
+				std::string vpcId_;
+				std::string coreDiskType_;
+				int logNodeCount_;
+				std::string logDiskType_;
+				std::string regionId_;
+				std::string expireTime_;
+				int coreDiskSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONECLUSTERRESULT_H_

hbase/include/alibabacloud/hbase/model/EvaluateMultiZoneResourceRequest.h

@@ -0,0 +1,129 @@
+/*
+ * 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_HBASE_MODEL_EVALUATEMULTIZONERESOURCEREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_EVALUATEMULTIZONERESOURCEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT EvaluateMultiZoneResourceRequest : public RpcServiceRequest
+			{
+
+			public:
+				EvaluateMultiZoneResourceRequest();
+				~EvaluateMultiZoneResourceRequest();
+
+				std::string getArchVersion()const;
+				void setArchVersion(const std::string& archVersion);
+				std::string getClusterName()const;
+				void setClusterName(const std::string& clusterName);
+				std::string getEngineVersion()const;
+				void setEngineVersion(const std::string& engineVersion);
+				std::string getLogDiskType()const;
+				void setLogDiskType(const std::string& logDiskType);
+				std::string getPrimaryVSwitchId()const;
+				void setPrimaryVSwitchId(const std::string& primaryVSwitchId);
+				std::string getLogInstanceType()const;
+				void setLogInstanceType(const std::string& logInstanceType);
+				int getAutoRenewPeriod()const;
+				void setAutoRenewPeriod(int autoRenewPeriod);
+				int getPeriod()const;
+				void setPeriod(int period);
+				int getLogNodeCount()const;
+				void setLogNodeCount(int logNodeCount);
+				std::string getSecurityIPList()const;
+				void setSecurityIPList(const std::string& securityIPList);
+				std::string getPeriodUnit()const;
+				void setPeriodUnit(const std::string& periodUnit);
+				std::string getCoreDiskType()const;
+				void setCoreDiskType(const std::string& coreDiskType);
+				std::string getArbiterZoneId()const;
+				void setArbiterZoneId(const std::string& arbiterZoneId);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getMultiZoneCombination()const;
+				void setMultiZoneCombination(const std::string& multiZoneCombination);
+				std::string getPrimaryZoneId()const;
+				void setPrimaryZoneId(const std::string& primaryZoneId);
+				std::string getEngine()const;
+				void setEngine(const std::string& engine);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getStandbyVSwitchId()const;
+				void setStandbyVSwitchId(const std::string& standbyVSwitchId);
+				std::string getStandbyZoneId()const;
+				void setStandbyZoneId(const std::string& standbyZoneId);
+				std::string getMasterInstanceType()const;
+				void setMasterInstanceType(const std::string& masterInstanceType);
+				int getCoreNodeCount()const;
+				void setCoreNodeCount(int coreNodeCount);
+				int getLogDiskSize()const;
+				void setLogDiskSize(int logDiskSize);
+				std::string getCoreInstanceType()const;
+				void setCoreInstanceType(const std::string& coreInstanceType);
+				int getCoreDiskSize()const;
+				void setCoreDiskSize(int coreDiskSize);
+				std::string getVpcId()const;
+				void setVpcId(const std::string& vpcId);
+				std::string getPayType()const;
+				void setPayType(const std::string& payType);
+				std::string getArbiterVSwitchId()const;
+				void setArbiterVSwitchId(const std::string& arbiterVSwitchId);
+
+            private:
+				std::string archVersion_;
+				std::string clusterName_;
+				std::string engineVersion_;
+				std::string logDiskType_;
+				std::string primaryVSwitchId_;
+				std::string logInstanceType_;
+				int autoRenewPeriod_;
+				int period_;
+				int logNodeCount_;
+				std::string securityIPList_;
+				std::string periodUnit_;
+				std::string coreDiskType_;
+				std::string arbiterZoneId_;
+				std::string clientToken_;
+				std::string multiZoneCombination_;
+				std::string primaryZoneId_;
+				std::string engine_;
+				std::string regionId_;
+				std::string standbyVSwitchId_;
+				std::string standbyZoneId_;
+				std::string masterInstanceType_;
+				int coreNodeCount_;
+				int logDiskSize_;
+				std::string coreInstanceType_;
+				int coreDiskSize_;
+				std::string vpcId_;
+				std::string payType_;
+				std::string arbiterVSwitchId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_EVALUATEMULTIZONERESOURCEREQUEST_H_

hbase/include/alibabacloud/hbase/model/EvaluateMultiZoneResourceResult.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_HBASE_MODEL_EVALUATEMULTIZONERESOURCERESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_EVALUATEMULTIZONERESOURCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT EvaluateMultiZoneResourceResult : public ServiceResult
+			{
+			public:
+
+
+				EvaluateMultiZoneResourceResult();
+				explicit EvaluateMultiZoneResourceResult(const std::string &payload);
+				~EvaluateMultiZoneResourceResult();
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_EVALUATEMULTIZONERESOURCERESULT_H_

hbase/include/alibabacloud/hbase/model/UpgradeMultiZoneClusterRequest.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_HBASE_MODEL_UPGRADEMULTIZONECLUSTERREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_UPGRADEMULTIZONECLUSTERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT UpgradeMultiZoneClusterRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpgradeMultiZoneClusterRequest();
+				~UpgradeMultiZoneClusterRequest();
+
+				std::string getRunMode()const;
+				void setRunMode(const std::string& runMode);
+				std::string getComponents()const;
+				void setComponents(const std::string& components);
+				std::string getUpgradeInsName()const;
+				void setUpgradeInsName(const std::string& upgradeInsName);
+				std::string getRestartComponents()const;
+				void setRestartComponents(const std::string& restartComponents);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getVersions()const;
+				void setVersions(const std::string& versions);
+
+            private:
+				std::string runMode_;
+				std::string components_;
+				std::string upgradeInsName_;
+				std::string restartComponents_;
+				std::string clusterId_;
+				std::string versions_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_UPGRADEMULTIZONECLUSTERREQUEST_H_

hbase/include/alibabacloud/hbase/model/UpgradeMultiZoneClusterResult.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_HBASE_MODEL_UPGRADEMULTIZONECLUSTERRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_UPGRADEMULTIZONECLUSTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT UpgradeMultiZoneClusterResult : public ServiceResult
+			{
+			public:
+
+
+				UpgradeMultiZoneClusterResult();
+				explicit UpgradeMultiZoneClusterResult(const std::string &payload);
+				~UpgradeMultiZoneClusterResult();
+				std::string getUpgradingComponents()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string upgradingComponents_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_UPGRADEMULTIZONECLUSTERRESULT_H_

hbase/src/HBaseClient.cc

@@ -303,6 +303,42 @@ HBaseClient::CreateRestorePlanOutcomeCallable HBaseClient::createRestorePlanCall
 	return task->get_future();
 }
 
+HBaseClient::DeleteHBaseHaDBOutcome HBaseClient::deleteHBaseHaDB(const DeleteHBaseHaDBRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteHBaseHaDBOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteHBaseHaDBOutcome(DeleteHBaseHaDBResult(outcome.result()));
+	else
+		return DeleteHBaseHaDBOutcome(outcome.error());
+}
+
+void HBaseClient::deleteHBaseHaDBAsync(const DeleteHBaseHaDBRequest& request, const DeleteHBaseHaDBAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteHBaseHaDB(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DeleteHBaseHaDBOutcomeCallable HBaseClient::deleteHBaseHaDBCallable(const DeleteHBaseHaDBRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteHBaseHaDBOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteHBaseHaDB(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::DeleteHbaseHaSlbOutcome HBaseClient::deleteHbaseHaSlb(const DeleteHbaseHaSlbRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -879,6 +915,114 @@ HBaseClient::DescribeIpWhitelistOutcomeCallable HBaseClient::describeIpWhitelist
 	return task->get_future();
 }
 
+HBaseClient::DescribeMultiZoneAvailableRegionsOutcome HBaseClient::describeMultiZoneAvailableRegions(const DescribeMultiZoneAvailableRegionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeMultiZoneAvailableRegionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeMultiZoneAvailableRegionsOutcome(DescribeMultiZoneAvailableRegionsResult(outcome.result()));
+	else
+		return DescribeMultiZoneAvailableRegionsOutcome(outcome.error());
+}
+
+void HBaseClient::describeMultiZoneAvailableRegionsAsync(const DescribeMultiZoneAvailableRegionsRequest& request, const DescribeMultiZoneAvailableRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeMultiZoneAvailableRegions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DescribeMultiZoneAvailableRegionsOutcomeCallable HBaseClient::describeMultiZoneAvailableRegionsCallable(const DescribeMultiZoneAvailableRegionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeMultiZoneAvailableRegionsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeMultiZoneAvailableRegions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::DescribeMultiZoneAvailableResourceOutcome HBaseClient::describeMultiZoneAvailableResource(const DescribeMultiZoneAvailableResourceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeMultiZoneAvailableResourceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeMultiZoneAvailableResourceOutcome(DescribeMultiZoneAvailableResourceResult(outcome.result()));
+	else
+		return DescribeMultiZoneAvailableResourceOutcome(outcome.error());
+}
+
+void HBaseClient::describeMultiZoneAvailableResourceAsync(const DescribeMultiZoneAvailableResourceRequest& request, const DescribeMultiZoneAvailableResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeMultiZoneAvailableResource(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DescribeMultiZoneAvailableResourceOutcomeCallable HBaseClient::describeMultiZoneAvailableResourceCallable(const DescribeMultiZoneAvailableResourceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeMultiZoneAvailableResourceOutcome()>>(
+			[this, request]()
+			{
+			return this->describeMultiZoneAvailableResource(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::DescribeMultiZoneClusterOutcome HBaseClient::describeMultiZoneCluster(const DescribeMultiZoneClusterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeMultiZoneClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeMultiZoneClusterOutcome(DescribeMultiZoneClusterResult(outcome.result()));
+	else
+		return DescribeMultiZoneClusterOutcome(outcome.error());
+}
+
+void HBaseClient::describeMultiZoneClusterAsync(const DescribeMultiZoneClusterRequest& request, const DescribeMultiZoneClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeMultiZoneCluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DescribeMultiZoneClusterOutcomeCallable HBaseClient::describeMultiZoneClusterCallable(const DescribeMultiZoneClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeMultiZoneClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->describeMultiZoneCluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::DescribeRecoverableTimeRangeOutcome HBaseClient::describeRecoverableTimeRange(const DescribeRecoverableTimeRangeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1239,6 +1383,42 @@ HBaseClient::EnableHBaseueModuleOutcomeCallable HBaseClient::enableHBaseueModule
 	return task->get_future();
 }
 
+HBaseClient::EvaluateMultiZoneResourceOutcome HBaseClient::evaluateMultiZoneResource(const EvaluateMultiZoneResourceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EvaluateMultiZoneResourceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EvaluateMultiZoneResourceOutcome(EvaluateMultiZoneResourceResult(outcome.result()));
+	else
+		return EvaluateMultiZoneResourceOutcome(outcome.error());
+}
+
+void HBaseClient::evaluateMultiZoneResourceAsync(const EvaluateMultiZoneResourceRequest& request, const EvaluateMultiZoneResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, evaluateMultiZoneResource(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::EvaluateMultiZoneResourceOutcomeCallable HBaseClient::evaluateMultiZoneResourceCallable(const EvaluateMultiZoneResourceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EvaluateMultiZoneResourceOutcome()>>(
+			[this, request]()
+			{
+			return this->evaluateMultiZoneResource(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::ListTagResourcesOutcome HBaseClient::listTagResources(const ListTagResourcesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1923,6 +2103,42 @@ HBaseClient::UnTagResourcesOutcomeCallable HBaseClient::unTagResourcesCallable(c
 	return task->get_future();
 }
 
+HBaseClient::UpgradeMultiZoneClusterOutcome HBaseClient::upgradeMultiZoneCluster(const UpgradeMultiZoneClusterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpgradeMultiZoneClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpgradeMultiZoneClusterOutcome(UpgradeMultiZoneClusterResult(outcome.result()));
+	else
+		return UpgradeMultiZoneClusterOutcome(outcome.error());
+}
+
+void HBaseClient::upgradeMultiZoneClusterAsync(const UpgradeMultiZoneClusterRequest& request, const UpgradeMultiZoneClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, upgradeMultiZoneCluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::UpgradeMultiZoneClusterOutcomeCallable HBaseClient::upgradeMultiZoneClusterCallable(const UpgradeMultiZoneClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpgradeMultiZoneClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->upgradeMultiZoneCluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::XpackRelateDBOutcome HBaseClient::xpackRelateDB(const XpackRelateDBRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

hbase/src/model/DeleteHBaseHaDBRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hbase/model/DeleteHBaseHaDBRequest.h>
+
+using AlibabaCloud::HBase::Model::DeleteHBaseHaDBRequest;
+
+DeleteHBaseHaDBRequest::DeleteHBaseHaDBRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "DeleteHBaseHaDB")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteHBaseHaDBRequest::~DeleteHBaseHaDBRequest()
+{}
+
+std::string DeleteHBaseHaDBRequest::getHaId()const
+{
+	return haId_;
+}
+
+void DeleteHBaseHaDBRequest::setHaId(const std::string& haId)
+{
+	haId_ = haId;
+	setParameter("HaId", haId);
+}
+
+std::string DeleteHBaseHaDBRequest::getBdsId()const
+{
+	return bdsId_;
+}
+
+void DeleteHBaseHaDBRequest::setBdsId(const std::string& bdsId)
+{
+	bdsId_ = bdsId;
+	setParameter("BdsId", bdsId);
+}
+

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

hbase/src/model/DescribeMultiZoneAvailableRegionsRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * 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/hbase/model/DescribeMultiZoneAvailableRegionsRequest.h>
+
+using AlibabaCloud::HBase::Model::DescribeMultiZoneAvailableRegionsRequest;
+
+DescribeMultiZoneAvailableRegionsRequest::DescribeMultiZoneAvailableRegionsRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "DescribeMultiZoneAvailableRegions")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeMultiZoneAvailableRegionsRequest::~DescribeMultiZoneAvailableRegionsRequest()
+{}
+
+std::string DescribeMultiZoneAvailableRegionsRequest::getAcceptLanguage()const
+{
+	return acceptLanguage_;
+}
+
+void DescribeMultiZoneAvailableRegionsRequest::setAcceptLanguage(const std::string& acceptLanguage)
+{
+	acceptLanguage_ = acceptLanguage;
+	setParameter("AcceptLanguage", acceptLanguage);
+}
+

hbase/src/model/DescribeMultiZoneAvailableRegionsResult.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/hbase/model/DescribeMultiZoneAvailableRegionsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+DescribeMultiZoneAvailableRegionsResult::DescribeMultiZoneAvailableRegionsResult() :
+	ServiceResult()
+{}
+
+DescribeMultiZoneAvailableRegionsResult::DescribeMultiZoneAvailableRegionsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeMultiZoneAvailableRegionsResult::~DescribeMultiZoneAvailableRegionsResult()
+{}
+
+void DescribeMultiZoneAvailableRegionsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allRegionsNode = value["Regions"]["Region"];
+	for (auto valueRegionsRegion : allRegionsNode)
+	{
+		Region regionsObject;
+		if(!valueRegionsRegion["LocalName"].isNull())
+			regionsObject.localName = valueRegionsRegion["LocalName"].asString();
+		if(!valueRegionsRegion["RegionEndpoint"].isNull())
+			regionsObject.regionEndpoint = valueRegionsRegion["RegionEndpoint"].asString();
+		if(!valueRegionsRegion["RegionId"].isNull())
+			regionsObject.regionId = valueRegionsRegion["RegionId"].asString();
+		auto allAvailableCombinesNode = allRegionsNode["AvailableCombines"]["AvailableCombine"];
+		for (auto allRegionsNodeAvailableCombinesAvailableCombine : allAvailableCombinesNode)
+		{
+			Region::AvailableCombine availableCombinesObject;
+			if(!allRegionsNodeAvailableCombinesAvailableCombine["Id"].isNull())
+				availableCombinesObject.id = allRegionsNodeAvailableCombinesAvailableCombine["Id"].asString();
+			auto allZones = value["Zones"]["Zone"];
+			for (auto value : allZones)
+				availableCombinesObject.zones.push_back(value.asString());
+			regionsObject.availableCombines.push_back(availableCombinesObject);
+		}
+		regions_.push_back(regionsObject);
+	}
+
+}
+
+std::vector<DescribeMultiZoneAvailableRegionsResult::Region> DescribeMultiZoneAvailableRegionsResult::getRegions()const
+{
+	return regions_;
+}
+

hbase/src/model/DescribeMultiZoneAvailableResourceRequest.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/hbase/model/DescribeMultiZoneAvailableResourceRequest.h>
+
+using AlibabaCloud::HBase::Model::DescribeMultiZoneAvailableResourceRequest;
+
+DescribeMultiZoneAvailableResourceRequest::DescribeMultiZoneAvailableResourceRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "DescribeMultiZoneAvailableResource")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeMultiZoneAvailableResourceRequest::~DescribeMultiZoneAvailableResourceRequest()
+{}
+
+std::string DescribeMultiZoneAvailableResourceRequest::getZoneCombination()const
+{
+	return zoneCombination_;
+}
+
+void DescribeMultiZoneAvailableResourceRequest::setZoneCombination(const std::string& zoneCombination)
+{
+	zoneCombination_ = zoneCombination;
+	setParameter("ZoneCombination", zoneCombination);
+}
+
+std::string DescribeMultiZoneAvailableResourceRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeMultiZoneAvailableResourceRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DescribeMultiZoneAvailableResourceRequest::getChargeType()const
+{
+	return chargeType_;
+}
+
+void DescribeMultiZoneAvailableResourceRequest::setChargeType(const std::string& chargeType)
+{
+	chargeType_ = chargeType;
+	setParameter("ChargeType", chargeType);
+}
+

hbase/src/model/DescribeMultiZoneAvailableResourceResult.cc

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hbase/model/DescribeMultiZoneAvailableResourceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+DescribeMultiZoneAvailableResourceResult::DescribeMultiZoneAvailableResourceResult() :
+	ServiceResult()
+{}
+
+DescribeMultiZoneAvailableResourceResult::DescribeMultiZoneAvailableResourceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeMultiZoneAvailableResourceResult::~DescribeMultiZoneAvailableResourceResult()
+{}
+
+void DescribeMultiZoneAvailableResourceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allAvailableZonesNode = value["AvailableZones"]["AvailableZone"];
+	for (auto valueAvailableZonesAvailableZone : allAvailableZonesNode)
+	{
+		AvailableZone availableZonesObject;
+		if(!valueAvailableZonesAvailableZone["RegionId"].isNull())
+			availableZonesObject.regionId = valueAvailableZonesAvailableZone["RegionId"].asString();
+		if(!valueAvailableZonesAvailableZone["ZoneCombination"].isNull())
+			availableZonesObject.zoneCombination = valueAvailableZonesAvailableZone["ZoneCombination"].asString();
+		auto allMasterResourcesNode = allAvailableZonesNode["MasterResources"]["MasterResource"];
+		for (auto allAvailableZonesNodeMasterResourcesMasterResource : allMasterResourcesNode)
+		{
+			AvailableZone::MasterResource masterResourcesObject;
+			if(!allAvailableZonesNodeMasterResourcesMasterResource["InstanceType"].isNull())
+				masterResourcesObject.instanceType = allAvailableZonesNodeMasterResourcesMasterResource["InstanceType"].asString();
+			auto instanceTypeDetailNode = value["InstanceTypeDetail"];
+			if(!instanceTypeDetailNode["Cpu"].isNull())
+				masterResourcesObject.instanceTypeDetail.cpu = std::stoi(instanceTypeDetailNode["Cpu"].asString());
+			if(!instanceTypeDetailNode["Mem"].isNull())
+				masterResourcesObject.instanceTypeDetail.mem = std::stoi(instanceTypeDetailNode["Mem"].asString());
+			availableZonesObject.masterResources.push_back(masterResourcesObject);
+		}
+		auto allSupportedEnginesNode = allAvailableZonesNode["SupportedEngines"]["SupportedEngine"];
+		for (auto allAvailableZonesNodeSupportedEnginesSupportedEngine : allSupportedEnginesNode)
+		{
+			AvailableZone::SupportedEngine supportedEnginesObject;
+			if(!allAvailableZonesNodeSupportedEnginesSupportedEngine["Engine"].isNull())
+				supportedEnginesObject.engine = allAvailableZonesNodeSupportedEnginesSupportedEngine["Engine"].asString();
+			auto allSupportedEngineVersionsNode = allSupportedEnginesNode["SupportedEngineVersions"]["SupportedEngineVersion"];
+			for (auto allSupportedEnginesNodeSupportedEngineVersionsSupportedEngineVersion : allSupportedEngineVersionsNode)
+			{
+				AvailableZone::SupportedEngine::SupportedEngineVersion supportedEngineVersionsObject;
+				if(!allSupportedEnginesNodeSupportedEngineVersionsSupportedEngineVersion["Version"].isNull())
+					supportedEngineVersionsObject.version = allSupportedEnginesNodeSupportedEngineVersionsSupportedEngineVersion["Version"].asString();
+				auto allSupportedCategoriesNode = allSupportedEngineVersionsNode["SupportedCategories"]["SupportedCategoriesItem"];
+				for (auto allSupportedEngineVersionsNodeSupportedCategoriesSupportedCategoriesItem : allSupportedCategoriesNode)
+				{
+					AvailableZone::SupportedEngine::SupportedEngineVersion::SupportedCategoriesItem supportedCategoriesObject;
+					if(!allSupportedEngineVersionsNodeSupportedCategoriesSupportedCategoriesItem["Category"].isNull())
+						supportedCategoriesObject.category = allSupportedEngineVersionsNodeSupportedCategoriesSupportedCategoriesItem["Category"].asString();
+					auto allSupportedStorageTypesNode = allSupportedCategoriesNode["SupportedStorageTypes"]["SupportedStorageType"];
+					for (auto allSupportedCategoriesNodeSupportedStorageTypesSupportedStorageType : allSupportedStorageTypesNode)
+					{
+						AvailableZone::SupportedEngine::SupportedEngineVersion::SupportedCategoriesItem::SupportedStorageType supportedStorageTypesObject;
+						if(!allSupportedCategoriesNodeSupportedStorageTypesSupportedStorageType["StorageType"].isNull())
+							supportedStorageTypesObject.storageType = allSupportedCategoriesNodeSupportedStorageTypesSupportedStorageType["StorageType"].asString();
+						auto allCoreResourcesNode = allSupportedStorageTypesNode["CoreResources"]["CoreResource"];
+						for (auto allSupportedStorageTypesNodeCoreResourcesCoreResource : allCoreResourcesNode)
+						{
+							AvailableZone::SupportedEngine::SupportedEngineVersion::SupportedCategoriesItem::SupportedStorageType::CoreResource coreResourcesObject;
+							if(!allSupportedStorageTypesNodeCoreResourcesCoreResource["InstanceType"].isNull())
+								coreResourcesObject.instanceType = allSupportedStorageTypesNodeCoreResourcesCoreResource["InstanceType"].asString();
+							if(!allSupportedStorageTypesNodeCoreResourcesCoreResource["MaxCoreCount"].isNull())
+								coreResourcesObject.maxCoreCount = std::stoi(allSupportedStorageTypesNodeCoreResourcesCoreResource["MaxCoreCount"].asString());
+							auto dBInstanceStorageRangeNode = value["DBInstanceStorageRange"];
+							if(!dBInstanceStorageRangeNode["MaxSize"].isNull())
+								coreResourcesObject.dBInstanceStorageRange.maxSize = std::stoi(dBInstanceStorageRangeNode["MaxSize"].asString());
+							if(!dBInstanceStorageRangeNode["MinSize"].isNull())
+								coreResourcesObject.dBInstanceStorageRange.minSize = std::stoi(dBInstanceStorageRangeNode["MinSize"].asString());
+							if(!dBInstanceStorageRangeNode["StepSize"].isNull())
+								coreResourcesObject.dBInstanceStorageRange.stepSize = std::stoi(dBInstanceStorageRangeNode["StepSize"].asString());
+							auto instanceTypeDetail1Node = value["InstanceTypeDetail"];
+							if(!instanceTypeDetail1Node["Cpu"].isNull())
+								coreResourcesObject.instanceTypeDetail1.cpu = std::stoi(instanceTypeDetail1Node["Cpu"].asString());
+							if(!instanceTypeDetail1Node["Mem"].isNull())
+								coreResourcesObject.instanceTypeDetail1.mem = std::stoi(instanceTypeDetail1Node["Mem"].asString());
+							supportedStorageTypesObject.coreResources.push_back(coreResourcesObject);
+						}
+						supportedCategoriesObject.supportedStorageTypes.push_back(supportedStorageTypesObject);
+					}
+					supportedEngineVersionsObject.supportedCategories.push_back(supportedCategoriesObject);
+				}
+				supportedEnginesObject.supportedEngineVersions.push_back(supportedEngineVersionsObject);
+			}
+			availableZonesObject.supportedEngines.push_back(supportedEnginesObject);
+		}
+		availableZones_.push_back(availableZonesObject);
+	}
+
+}
+
+std::vector<DescribeMultiZoneAvailableResourceResult::AvailableZone> DescribeMultiZoneAvailableResourceResult::getAvailableZones()const
+{
+	return availableZones_;
+}
+

hbase/src/model/DescribeMultiZoneClusterRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * 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/hbase/model/DescribeMultiZoneClusterRequest.h>
+
+using AlibabaCloud::HBase::Model::DescribeMultiZoneClusterRequest;
+
+DescribeMultiZoneClusterRequest::DescribeMultiZoneClusterRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "DescribeMultiZoneCluster")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeMultiZoneClusterRequest::~DescribeMultiZoneClusterRequest()
+{}
+
+std::string DescribeMultiZoneClusterRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void DescribeMultiZoneClusterRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+

hbase/src/model/DescribeMultiZoneClusterResult.cc

@@ -0,0 +1,388 @@
+/*
+ * 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/hbase/model/DescribeMultiZoneClusterResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+DescribeMultiZoneClusterResult::DescribeMultiZoneClusterResult() :
+	ServiceResult()
+{}
+
+DescribeMultiZoneClusterResult::DescribeMultiZoneClusterResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeMultiZoneClusterResult::~DescribeMultiZoneClusterResult()
+{}
+
+void DescribeMultiZoneClusterResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allMultiZoneInstanceModelsNode = value["MultiZoneInstanceModels"]["MultiZoneInstanceModel"];
+	for (auto valueMultiZoneInstanceModelsMultiZoneInstanceModel : allMultiZoneInstanceModelsNode)
+	{
+		MultiZoneInstanceModel multiZoneInstanceModelsObject;
+		if(!valueMultiZoneInstanceModelsMultiZoneInstanceModel["InsName"].isNull())
+			multiZoneInstanceModelsObject.insName = valueMultiZoneInstanceModelsMultiZoneInstanceModel["InsName"].asString();
+		if(!valueMultiZoneInstanceModelsMultiZoneInstanceModel["IsLatestVersion"].isNull())
+			multiZoneInstanceModelsObject.isLatestVersion = valueMultiZoneInstanceModelsMultiZoneInstanceModel["IsLatestVersion"].asString() == "true";
+		if(!valueMultiZoneInstanceModelsMultiZoneInstanceModel["MinorVersion"].isNull())
+			multiZoneInstanceModelsObject.minorVersion = valueMultiZoneInstanceModelsMultiZoneInstanceModel["MinorVersion"].asString();
+		if(!valueMultiZoneInstanceModelsMultiZoneInstanceModel["Status"].isNull())
+			multiZoneInstanceModelsObject.status = valueMultiZoneInstanceModelsMultiZoneInstanceModel["Status"].asString();
+		if(!valueMultiZoneInstanceModelsMultiZoneInstanceModel["Role"].isNull())
+			multiZoneInstanceModelsObject.role = valueMultiZoneInstanceModelsMultiZoneInstanceModel["Role"].asString();
+		multiZoneInstanceModels_.push_back(multiZoneInstanceModelsObject);
+	}
+	auto allTagsNode = value["Tags"]["Tag"];
+	for (auto valueTagsTag : allTagsNode)
+	{
+		Tag tagsObject;
+		if(!valueTagsTag["Key"].isNull())
+			tagsObject.key = valueTagsTag["Key"].asString();
+		if(!valueTagsTag["Value"].isNull())
+			tagsObject.value = valueTagsTag["Value"].asString();
+		tags_.push_back(tagsObject);
+	}
+	if(!value["AutoRenewal"].isNull())
+		autoRenewal_ = value["AutoRenewal"].asString() == "true";
+	if(!value["ClusterId"].isNull())
+		clusterId_ = value["ClusterId"].asString();
+	if(!value["ClusterName"].isNull())
+		clusterName_ = value["ClusterName"].asString();
+	if(!value["CreatedTime"].isNull())
+		createdTime_ = value["CreatedTime"].asString();
+	if(!value["CreatedTimeUTC"].isNull())
+		createdTimeUTC_ = value["CreatedTimeUTC"].asString();
+	if(!value["Duration"].isNull())
+		duration_ = std::stoi(value["Duration"].asString());
+	if(!value["Engine"].isNull())
+		engine_ = value["Engine"].asString();
+	if(!value["ExpireTime"].isNull())
+		expireTime_ = value["ExpireTime"].asString();
+	if(!value["ExpireTimeUTC"].isNull())
+		expireTimeUTC_ = value["ExpireTimeUTC"].asString();
+	if(!value["InstanceId"].isNull())
+		instanceId_ = value["InstanceId"].asString();
+	if(!value["InstanceName"].isNull())
+		instanceName_ = value["InstanceName"].asString();
+	if(!value["IsDeletionProtection"].isNull())
+		isDeletionProtection_ = value["IsDeletionProtection"].asString() == "true";
+	if(!value["MaintainEndTime"].isNull())
+		maintainEndTime_ = value["MaintainEndTime"].asString();
+	if(!value["MaintainStartTime"].isNull())
+		maintainStartTime_ = value["MaintainStartTime"].asString();
+	if(!value["MajorVersion"].isNull())
+		majorVersion_ = value["MajorVersion"].asString();
+	if(!value["MasterDiskSize"].isNull())
+		masterDiskSize_ = std::stoi(value["MasterDiskSize"].asString());
+	if(!value["MasterDiskType"].isNull())
+		masterDiskType_ = value["MasterDiskType"].asString();
+	if(!value["MasterInstanceType"].isNull())
+		masterInstanceType_ = value["MasterInstanceType"].asString();
+	if(!value["MasterNodeCount"].isNull())
+		masterNodeCount_ = std::stoi(value["MasterNodeCount"].asString());
+	if(!value["CoreDiskCount"].isNull())
+		coreDiskCount_ = value["CoreDiskCount"].asString();
+	if(!value["CoreDiskSize"].isNull())
+		coreDiskSize_ = std::stoi(value["CoreDiskSize"].asString());
+	if(!value["CoreDiskType"].isNull())
+		coreDiskType_ = value["CoreDiskType"].asString();
+	if(!value["CoreInstanceType"].isNull())
+		coreInstanceType_ = value["CoreInstanceType"].asString();
+	if(!value["CoreNodeCount"].isNull())
+		coreNodeCount_ = std::stoi(value["CoreNodeCount"].asString());
+	if(!value["LogDiskCount"].isNull())
+		logDiskCount_ = value["LogDiskCount"].asString();
+	if(!value["LogDiskSize"].isNull())
+		logDiskSize_ = std::stoi(value["LogDiskSize"].asString());
+	if(!value["LogDiskType"].isNull())
+		logDiskType_ = value["LogDiskType"].asString();
+	if(!value["LogInstanceType"].isNull())
+		logInstanceType_ = value["LogInstanceType"].asString();
+	if(!value["LogNodeCount"].isNull())
+		logNodeCount_ = std::stoi(value["LogNodeCount"].asString());
+	if(!value["ModuleId"].isNull())
+		moduleId_ = std::stoi(value["ModuleId"].asString());
+	if(!value["ModuleStackVersion"].isNull())
+		moduleStackVersion_ = value["ModuleStackVersion"].asString();
+	if(!value["NetworkType"].isNull())
+		networkType_ = value["NetworkType"].asString();
+	if(!value["ParentId"].isNull())
+		parentId_ = value["ParentId"].asString();
+	if(!value["PayType"].isNull())
+		payType_ = value["PayType"].asString();
+	if(!value["RegionId"].isNull())
+		regionId_ = value["RegionId"].asString();
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["MultiZoneCombination"].isNull())
+		multiZoneCombination_ = value["MultiZoneCombination"].asString();
+	if(!value["PrimaryZoneId"].isNull())
+		primaryZoneId_ = value["PrimaryZoneId"].asString();
+	if(!value["PrimaryVSwitchIds"].isNull())
+		primaryVSwitchIds_ = value["PrimaryVSwitchIds"].asString();
+	if(!value["StandbyZoneId"].isNull())
+		standbyZoneId_ = value["StandbyZoneId"].asString();
+	if(!value["StandbyVSwitchIds"].isNull())
+		standbyVSwitchIds_ = value["StandbyVSwitchIds"].asString();
+	if(!value["ArbiterZoneId"].isNull())
+		arbiterZoneId_ = value["ArbiterZoneId"].asString();
+	if(!value["ArbiterVSwitchIds"].isNull())
+		arbiterVSwitchIds_ = value["ArbiterVSwitchIds"].asString();
+	if(!value["VpcId"].isNull())
+		vpcId_ = value["VpcId"].asString();
+
+}
+
+std::string DescribeMultiZoneClusterResult::getModuleStackVersion()const
+{
+	return moduleStackVersion_;
+}
+
+std::string DescribeMultiZoneClusterResult::getStandbyZoneId()const
+{
+	return standbyZoneId_;
+}
+
+std::string DescribeMultiZoneClusterResult::getCreatedTime()const
+{
+	return createdTime_;
+}
+
+std::string DescribeMultiZoneClusterResult::getMasterInstanceType()const
+{
+	return masterInstanceType_;
+}
+
+std::string DescribeMultiZoneClusterResult::getPrimaryVSwitchIds()const
+{
+	return primaryVSwitchIds_;
+}
+
+bool DescribeMultiZoneClusterResult::getIsDeletionProtection()const
+{
+	return isDeletionProtection_;
+}
+
+std::string DescribeMultiZoneClusterResult::getLogDiskCount()const
+{
+	return logDiskCount_;
+}
+
+int DescribeMultiZoneClusterResult::getLogDiskSize()const
+{
+	return logDiskSize_;
+}
+
+int DescribeMultiZoneClusterResult::getModuleId()const
+{
+	return moduleId_;
+}
+
+std::string DescribeMultiZoneClusterResult::getArbiterVSwitchIds()const
+{
+	return arbiterVSwitchIds_;
+}
+
+std::string DescribeMultiZoneClusterResult::getMaintainEndTime()const
+{
+	return maintainEndTime_;
+}
+
+std::string DescribeMultiZoneClusterResult::getStandbyVSwitchIds()const
+{
+	return standbyVSwitchIds_;
+}
+
+std::string DescribeMultiZoneClusterResult::getNetworkType()const
+{
+	return networkType_;
+}
+
+std::string DescribeMultiZoneClusterResult::getCoreInstanceType()const
+{
+	return coreInstanceType_;
+}
+
+std::string DescribeMultiZoneClusterResult::getClusterName()const
+{
+	return clusterName_;
+}
+
+std::string DescribeMultiZoneClusterResult::getMasterDiskType()const
+{
+	return masterDiskType_;
+}
+
+std::vector<DescribeMultiZoneClusterResult::Tag> DescribeMultiZoneClusterResult::getTags()const
+{
+	return tags_;
+}
+
+std::string DescribeMultiZoneClusterResult::getEngine()const
+{
+	return engine_;
+}
+
+std::string DescribeMultiZoneClusterResult::getMaintainStartTime()const
+{
+	return maintainStartTime_;
+}
+
+std::string DescribeMultiZoneClusterResult::getArbiterZoneId()const
+{
+	return arbiterZoneId_;
+}
+
+std::string DescribeMultiZoneClusterResult::getMajorVersion()const
+{
+	return majorVersion_;
+}
+
+std::string DescribeMultiZoneClusterResult::getCoreDiskCount()const
+{
+	return coreDiskCount_;
+}
+
+std::string DescribeMultiZoneClusterResult::getParentId()const
+{
+	return parentId_;
+}
+
+std::string DescribeMultiZoneClusterResult::getStatus()const
+{
+	return status_;
+}
+
+std::vector<DescribeMultiZoneClusterResult::MultiZoneInstanceModel> DescribeMultiZoneClusterResult::getMultiZoneInstanceModels()const
+{
+	return multiZoneInstanceModels_;
+}
+
+std::string DescribeMultiZoneClusterResult::getExpireTimeUTC()const
+{
+	return expireTimeUTC_;
+}
+
+int DescribeMultiZoneClusterResult::getMasterDiskSize()const
+{
+	return masterDiskSize_;
+}
+
+std::string DescribeMultiZoneClusterResult::getPrimaryZoneId()const
+{
+	return primaryZoneId_;
+}
+
+std::string DescribeMultiZoneClusterResult::getMultiZoneCombination()const
+{
+	return multiZoneCombination_;
+}
+
+std::string DescribeMultiZoneClusterResult::getClusterId()const
+{
+	return clusterId_;
+}
+
+std::string DescribeMultiZoneClusterResult::getInstanceId()const
+{
+	return instanceId_;
+}
+
+int DescribeMultiZoneClusterResult::getCoreNodeCount()const
+{
+	return coreNodeCount_;
+}
+
+std::string DescribeMultiZoneClusterResult::getCreatedTimeUTC()const
+{
+	return createdTimeUTC_;
+}
+
+int DescribeMultiZoneClusterResult::getDuration()const
+{
+	return duration_;
+}
+
+std::string DescribeMultiZoneClusterResult::getLogInstanceType()const
+{
+	return logInstanceType_;
+}
+
+std::string DescribeMultiZoneClusterResult::getPayType()const
+{
+	return payType_;
+}
+
+std::string DescribeMultiZoneClusterResult::getInstanceName()const
+{
+	return instanceName_;
+}
+
+int DescribeMultiZoneClusterResult::getMasterNodeCount()const
+{
+	return masterNodeCount_;
+}
+
+bool DescribeMultiZoneClusterResult::getAutoRenewal()const
+{
+	return autoRenewal_;
+}
+
+std::string DescribeMultiZoneClusterResult::getVpcId()const
+{
+	return vpcId_;
+}
+
+std::string DescribeMultiZoneClusterResult::getCoreDiskType()const
+{
+	return coreDiskType_;
+}
+
+int DescribeMultiZoneClusterResult::getLogNodeCount()const
+{
+	return logNodeCount_;
+}
+
+std::string DescribeMultiZoneClusterResult::getLogDiskType()const
+{
+	return logDiskType_;
+}
+
+std::string DescribeMultiZoneClusterResult::getRegionId()const
+{
+	return regionId_;
+}
+
+std::string DescribeMultiZoneClusterResult::getExpireTime()const
+{
+	return expireTime_;
+}
+
+int DescribeMultiZoneClusterResult::getCoreDiskSize()const
+{
+	return coreDiskSize_;
+}
+

hbase/src/model/EvaluateMultiZoneResourceRequest.cc

@@ -0,0 +1,337 @@
+/*
+ * 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/hbase/model/EvaluateMultiZoneResourceRequest.h>
+
+using AlibabaCloud::HBase::Model::EvaluateMultiZoneResourceRequest;
+
+EvaluateMultiZoneResourceRequest::EvaluateMultiZoneResourceRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "EvaluateMultiZoneResource")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+EvaluateMultiZoneResourceRequest::~EvaluateMultiZoneResourceRequest()
+{}
+
+std::string EvaluateMultiZoneResourceRequest::getArchVersion()const
+{
+	return archVersion_;
+}
+
+void EvaluateMultiZoneResourceRequest::setArchVersion(const std::string& archVersion)
+{
+	archVersion_ = archVersion;
+	setParameter("ArchVersion", archVersion);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getClusterName()const
+{
+	return clusterName_;
+}
+
+void EvaluateMultiZoneResourceRequest::setClusterName(const std::string& clusterName)
+{
+	clusterName_ = clusterName;
+	setParameter("ClusterName", clusterName);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getEngineVersion()const
+{
+	return engineVersion_;
+}
+
+void EvaluateMultiZoneResourceRequest::setEngineVersion(const std::string& engineVersion)
+{
+	engineVersion_ = engineVersion;
+	setParameter("EngineVersion", engineVersion);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getLogDiskType()const
+{
+	return logDiskType_;
+}
+
+void EvaluateMultiZoneResourceRequest::setLogDiskType(const std::string& logDiskType)
+{
+	logDiskType_ = logDiskType;
+	setParameter("LogDiskType", logDiskType);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getPrimaryVSwitchId()const
+{
+	return primaryVSwitchId_;
+}
+
+void EvaluateMultiZoneResourceRequest::setPrimaryVSwitchId(const std::string& primaryVSwitchId)
+{
+	primaryVSwitchId_ = primaryVSwitchId;
+	setParameter("PrimaryVSwitchId", primaryVSwitchId);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getLogInstanceType()const
+{
+	return logInstanceType_;
+}
+
+void EvaluateMultiZoneResourceRequest::setLogInstanceType(const std::string& logInstanceType)
+{
+	logInstanceType_ = logInstanceType;
+	setParameter("LogInstanceType", logInstanceType);
+}
+
+int EvaluateMultiZoneResourceRequest::getAutoRenewPeriod()const
+{
+	return autoRenewPeriod_;
+}
+
+void EvaluateMultiZoneResourceRequest::setAutoRenewPeriod(int autoRenewPeriod)
+{
+	autoRenewPeriod_ = autoRenewPeriod;
+	setParameter("AutoRenewPeriod", std::to_string(autoRenewPeriod));
+}
+
+int EvaluateMultiZoneResourceRequest::getPeriod()const
+{
+	return period_;
+}
+
+void EvaluateMultiZoneResourceRequest::setPeriod(int period)
+{
+	period_ = period;
+	setParameter("Period", std::to_string(period));
+}
+
+int EvaluateMultiZoneResourceRequest::getLogNodeCount()const
+{
+	return logNodeCount_;
+}
+
+void EvaluateMultiZoneResourceRequest::setLogNodeCount(int logNodeCount)
+{
+	logNodeCount_ = logNodeCount;
+	setParameter("LogNodeCount", std::to_string(logNodeCount));
+}
+
+std::string EvaluateMultiZoneResourceRequest::getSecurityIPList()const
+{
+	return securityIPList_;
+}
+
+void EvaluateMultiZoneResourceRequest::setSecurityIPList(const std::string& securityIPList)
+{
+	securityIPList_ = securityIPList;
+	setParameter("SecurityIPList", securityIPList);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getPeriodUnit()const
+{
+	return periodUnit_;
+}
+
+void EvaluateMultiZoneResourceRequest::setPeriodUnit(const std::string& periodUnit)
+{
+	periodUnit_ = periodUnit;
+	setParameter("PeriodUnit", periodUnit);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getCoreDiskType()const
+{
+	return coreDiskType_;
+}
+
+void EvaluateMultiZoneResourceRequest::setCoreDiskType(const std::string& coreDiskType)
+{
+	coreDiskType_ = coreDiskType;
+	setParameter("CoreDiskType", coreDiskType);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getArbiterZoneId()const
+{
+	return arbiterZoneId_;
+}
+
+void EvaluateMultiZoneResourceRequest::setArbiterZoneId(const std::string& arbiterZoneId)
+{
+	arbiterZoneId_ = arbiterZoneId;
+	setParameter("ArbiterZoneId", arbiterZoneId);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void EvaluateMultiZoneResourceRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getMultiZoneCombination()const
+{
+	return multiZoneCombination_;
+}
+
+void EvaluateMultiZoneResourceRequest::setMultiZoneCombination(const std::string& multiZoneCombination)
+{
+	multiZoneCombination_ = multiZoneCombination;
+	setParameter("MultiZoneCombination", multiZoneCombination);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getPrimaryZoneId()const
+{
+	return primaryZoneId_;
+}
+
+void EvaluateMultiZoneResourceRequest::setPrimaryZoneId(const std::string& primaryZoneId)
+{
+	primaryZoneId_ = primaryZoneId;
+	setParameter("PrimaryZoneId", primaryZoneId);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getEngine()const
+{
+	return engine_;
+}
+
+void EvaluateMultiZoneResourceRequest::setEngine(const std::string& engine)
+{
+	engine_ = engine;
+	setParameter("Engine", engine);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void EvaluateMultiZoneResourceRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getStandbyVSwitchId()const
+{
+	return standbyVSwitchId_;
+}
+
+void EvaluateMultiZoneResourceRequest::setStandbyVSwitchId(const std::string& standbyVSwitchId)
+{
+	standbyVSwitchId_ = standbyVSwitchId;
+	setParameter("StandbyVSwitchId", standbyVSwitchId);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getStandbyZoneId()const
+{
+	return standbyZoneId_;
+}
+
+void EvaluateMultiZoneResourceRequest::setStandbyZoneId(const std::string& standbyZoneId)
+{
+	standbyZoneId_ = standbyZoneId;
+	setParameter("StandbyZoneId", standbyZoneId);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getMasterInstanceType()const
+{
+	return masterInstanceType_;
+}
+
+void EvaluateMultiZoneResourceRequest::setMasterInstanceType(const std::string& masterInstanceType)
+{
+	masterInstanceType_ = masterInstanceType;
+	setParameter("MasterInstanceType", masterInstanceType);
+}
+
+int EvaluateMultiZoneResourceRequest::getCoreNodeCount()const
+{
+	return coreNodeCount_;
+}
+
+void EvaluateMultiZoneResourceRequest::setCoreNodeCount(int coreNodeCount)
+{
+	coreNodeCount_ = coreNodeCount;
+	setParameter("CoreNodeCount", std::to_string(coreNodeCount));
+}
+
+int EvaluateMultiZoneResourceRequest::getLogDiskSize()const
+{
+	return logDiskSize_;
+}
+
+void EvaluateMultiZoneResourceRequest::setLogDiskSize(int logDiskSize)
+{
+	logDiskSize_ = logDiskSize;
+	setParameter("LogDiskSize", std::to_string(logDiskSize));
+}
+
+std::string EvaluateMultiZoneResourceRequest::getCoreInstanceType()const
+{
+	return coreInstanceType_;
+}
+
+void EvaluateMultiZoneResourceRequest::setCoreInstanceType(const std::string& coreInstanceType)
+{
+	coreInstanceType_ = coreInstanceType;
+	setParameter("CoreInstanceType", coreInstanceType);
+}
+
+int EvaluateMultiZoneResourceRequest::getCoreDiskSize()const
+{
+	return coreDiskSize_;
+}
+
+void EvaluateMultiZoneResourceRequest::setCoreDiskSize(int coreDiskSize)
+{
+	coreDiskSize_ = coreDiskSize;
+	setParameter("CoreDiskSize", std::to_string(coreDiskSize));
+}
+
+std::string EvaluateMultiZoneResourceRequest::getVpcId()const
+{
+	return vpcId_;
+}
+
+void EvaluateMultiZoneResourceRequest::setVpcId(const std::string& vpcId)
+{
+	vpcId_ = vpcId;
+	setParameter("VpcId", vpcId);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getPayType()const
+{
+	return payType_;
+}
+
+void EvaluateMultiZoneResourceRequest::setPayType(const std::string& payType)
+{
+	payType_ = payType;
+	setParameter("PayType", payType);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getArbiterVSwitchId()const
+{
+	return arbiterVSwitchId_;
+}
+
+void EvaluateMultiZoneResourceRequest::setArbiterVSwitchId(const std::string& arbiterVSwitchId)
+{
+	arbiterVSwitchId_ = arbiterVSwitchId;
+	setParameter("ArbiterVSwitchId", arbiterVSwitchId);
+}
+

hbase/src/model/EvaluateMultiZoneResourceResult.cc

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

hbase/src/model/UpgradeMultiZoneClusterRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hbase/model/UpgradeMultiZoneClusterRequest.h>
+
+using AlibabaCloud::HBase::Model::UpgradeMultiZoneClusterRequest;
+
+UpgradeMultiZoneClusterRequest::UpgradeMultiZoneClusterRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "UpgradeMultiZoneCluster")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+UpgradeMultiZoneClusterRequest::~UpgradeMultiZoneClusterRequest()
+{}
+
+std::string UpgradeMultiZoneClusterRequest::getRunMode()const
+{
+	return runMode_;
+}
+
+void UpgradeMultiZoneClusterRequest::setRunMode(const std::string& runMode)
+{
+	runMode_ = runMode;
+	setParameter("RunMode", runMode);
+}
+
+std::string UpgradeMultiZoneClusterRequest::getComponents()const
+{
+	return components_;
+}
+
+void UpgradeMultiZoneClusterRequest::setComponents(const std::string& components)
+{
+	components_ = components;
+	setParameter("Components", components);
+}
+
+std::string UpgradeMultiZoneClusterRequest::getUpgradeInsName()const
+{
+	return upgradeInsName_;
+}
+
+void UpgradeMultiZoneClusterRequest::setUpgradeInsName(const std::string& upgradeInsName)
+{
+	upgradeInsName_ = upgradeInsName;
+	setParameter("UpgradeInsName", upgradeInsName);
+}
+
+std::string UpgradeMultiZoneClusterRequest::getRestartComponents()const
+{
+	return restartComponents_;
+}
+
+void UpgradeMultiZoneClusterRequest::setRestartComponents(const std::string& restartComponents)
+{
+	restartComponents_ = restartComponents;
+	setParameter("RestartComponents", restartComponents);
+}
+
+std::string UpgradeMultiZoneClusterRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void UpgradeMultiZoneClusterRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
+std::string UpgradeMultiZoneClusterRequest::getVersions()const
+{
+	return versions_;
+}
+
+void UpgradeMultiZoneClusterRequest::setVersions(const std::string& versions)
+{
+	versions_ = versions;
+	setParameter("Versions", versions);
+}
+

hbase/src/model/UpgradeMultiZoneClusterResult.cc

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

live/CMakeLists.txt

@@ -61,6 +61,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/AddLiveSnapshotDetectPornConfigResult.h
 	include/alibabacloud/live/model/AddLiveStreamTranscodeRequest.h
 	include/alibabacloud/live/model/AddLiveStreamTranscodeResult.h
+	include/alibabacloud/live/model/AddRtsLiveStreamTranscodeRequest.h
+	include/alibabacloud/live/model/AddRtsLiveStreamTranscodeResult.h
 	include/alibabacloud/live/model/AddTrancodeSEIRequest.h
 	include/alibabacloud/live/model/AddTrancodeSEIResult.h
 	include/alibabacloud/live/model/AllowPushStreamRequest.h
@@ -199,12 +201,16 @@ set(live_public_header_model
 	include/alibabacloud/live/model/DescribeLiveDomainBpsDataResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainBpsDataByTimeStampRequest.h
 	include/alibabacloud/live/model/DescribeLiveDomainBpsDataByTimeStampResult.h
+	include/alibabacloud/live/model/DescribeLiveDomainCertificateInfoRequest.h
+	include/alibabacloud/live/model/DescribeLiveDomainCertificateInfoResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainConfigsRequest.h
 	include/alibabacloud/live/model/DescribeLiveDomainConfigsResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainDetailRequest.h
 	include/alibabacloud/live/model/DescribeLiveDomainDetailResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainFrameRateAndBitRateDataRequest.h
 	include/alibabacloud/live/model/DescribeLiveDomainFrameRateAndBitRateDataResult.h
+	include/alibabacloud/live/model/DescribeLiveDomainLimitRequest.h
+	include/alibabacloud/live/model/DescribeLiveDomainLimitResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainMappingRequest.h
 	include/alibabacloud/live/model/DescribeLiveDomainMappingResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainOnlineUserNumRequest.h
@@ -225,14 +231,14 @@ set(live_public_header_model
 	include/alibabacloud/live/model/DescribeLiveDomainRecordDataResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainSnapshotDataRequest.h
 	include/alibabacloud/live/model/DescribeLiveDomainSnapshotDataResult.h
+	include/alibabacloud/live/model/DescribeLiveDomainTimeShiftDataRequest.h
+	include/alibabacloud/live/model/DescribeLiveDomainTimeShiftDataResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainTrafficDataRequest.h
 	include/alibabacloud/live/model/DescribeLiveDomainTrafficDataResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainTranscodeDataRequest.h
 	include/alibabacloud/live/model/DescribeLiveDomainTranscodeDataResult.h
 	include/alibabacloud/live/model/DescribeLiveLazyPullStreamConfigRequest.h
 	include/alibabacloud/live/model/DescribeLiveLazyPullStreamConfigResult.h
-	include/alibabacloud/live/model/DescribeLivePullStreamConfigRequest.h
-	include/alibabacloud/live/model/DescribeLivePullStreamConfigResult.h
 	include/alibabacloud/live/model/DescribeLiveRealtimeDeliveryAccRequest.h
 	include/alibabacloud/live/model/DescribeLiveRealtimeDeliveryAccResult.h
 	include/alibabacloud/live/model/DescribeLiveRealtimeLogAuthorizedRequest.h
@@ -460,6 +466,8 @@ set(live_src
 	src/model/AddLiveSnapshotDetectPornConfigResult.cc
 	src/model/AddLiveStreamTranscodeRequest.cc
 	src/model/AddLiveStreamTranscodeResult.cc
+	src/model/AddRtsLiveStreamTranscodeRequest.cc
+	src/model/AddRtsLiveStreamTranscodeResult.cc
 	src/model/AddTrancodeSEIRequest.cc
 	src/model/AddTrancodeSEIResult.cc
 	src/model/AllowPushStreamRequest.cc
@@ -598,12 +606,16 @@ set(live_src
 	src/model/DescribeLiveDomainBpsDataResult.cc
 	src/model/DescribeLiveDomainBpsDataByTimeStampRequest.cc
 	src/model/DescribeLiveDomainBpsDataByTimeStampResult.cc
+	src/model/DescribeLiveDomainCertificateInfoRequest.cc
+	src/model/DescribeLiveDomainCertificateInfoResult.cc
 	src/model/DescribeLiveDomainConfigsRequest.cc
 	src/model/DescribeLiveDomainConfigsResult.cc
 	src/model/DescribeLiveDomainDetailRequest.cc
 	src/model/DescribeLiveDomainDetailResult.cc
 	src/model/DescribeLiveDomainFrameRateAndBitRateDataRequest.cc
 	src/model/DescribeLiveDomainFrameRateAndBitRateDataResult.cc
+	src/model/DescribeLiveDomainLimitRequest.cc
+	src/model/DescribeLiveDomainLimitResult.cc
 	src/model/DescribeLiveDomainMappingRequest.cc
 	src/model/DescribeLiveDomainMappingResult.cc
 	src/model/DescribeLiveDomainOnlineUserNumRequest.cc
@@ -624,14 +636,14 @@ set(live_src
 	src/model/DescribeLiveDomainRecordDataResult.cc
 	src/model/DescribeLiveDomainSnapshotDataRequest.cc
 	src/model/DescribeLiveDomainSnapshotDataResult.cc
+	src/model/DescribeLiveDomainTimeShiftDataRequest.cc
+	src/model/DescribeLiveDomainTimeShiftDataResult.cc
 	src/model/DescribeLiveDomainTrafficDataRequest.cc
 	src/model/DescribeLiveDomainTrafficDataResult.cc
 	src/model/DescribeLiveDomainTranscodeDataRequest.cc
 	src/model/DescribeLiveDomainTranscodeDataResult.cc
 	src/model/DescribeLiveLazyPullStreamConfigRequest.cc
 	src/model/DescribeLiveLazyPullStreamConfigResult.cc
-	src/model/DescribeLivePullStreamConfigRequest.cc
-	src/model/DescribeLivePullStreamConfigResult.cc
 	src/model/DescribeLiveRealtimeDeliveryAccRequest.cc
 	src/model/DescribeLiveRealtimeDeliveryAccResult.cc
 	src/model/DescribeLiveRealtimeLogAuthorizedRequest.cc

live/include/alibabacloud/live/LiveClient.h

@@ -62,6 +62,8 @@
 #include "model/AddLiveSnapshotDetectPornConfigResult.h"
 #include "model/AddLiveStreamTranscodeRequest.h"
 #include "model/AddLiveStreamTranscodeResult.h"
+#include "model/AddRtsLiveStreamTranscodeRequest.h"
+#include "model/AddRtsLiveStreamTranscodeResult.h"
 #include "model/AddTrancodeSEIRequest.h"
 #include "model/AddTrancodeSEIResult.h"
 #include "model/AllowPushStreamRequest.h"
@@ -200,12 +202,16 @@
 #include "model/DescribeLiveDomainBpsDataResult.h"
 #include "model/DescribeLiveDomainBpsDataByTimeStampRequest.h"
 #include "model/DescribeLiveDomainBpsDataByTimeStampResult.h"
+#include "model/DescribeLiveDomainCertificateInfoRequest.h"
+#include "model/DescribeLiveDomainCertificateInfoResult.h"
 #include "model/DescribeLiveDomainConfigsRequest.h"
 #include "model/DescribeLiveDomainConfigsResult.h"
 #include "model/DescribeLiveDomainDetailRequest.h"
 #include "model/DescribeLiveDomainDetailResult.h"
 #include "model/DescribeLiveDomainFrameRateAndBitRateDataRequest.h"
 #include "model/DescribeLiveDomainFrameRateAndBitRateDataResult.h"
+#include "model/DescribeLiveDomainLimitRequest.h"
+#include "model/DescribeLiveDomainLimitResult.h"
 #include "model/DescribeLiveDomainMappingRequest.h"
 #include "model/DescribeLiveDomainMappingResult.h"
 #include "model/DescribeLiveDomainOnlineUserNumRequest.h"
@@ -226,14 +232,14 @@
 #include "model/DescribeLiveDomainRecordDataResult.h"
 #include "model/DescribeLiveDomainSnapshotDataRequest.h"
 #include "model/DescribeLiveDomainSnapshotDataResult.h"
+#include "model/DescribeLiveDomainTimeShiftDataRequest.h"
+#include "model/DescribeLiveDomainTimeShiftDataResult.h"
 #include "model/DescribeLiveDomainTrafficDataRequest.h"
 #include "model/DescribeLiveDomainTrafficDataResult.h"
 #include "model/DescribeLiveDomainTranscodeDataRequest.h"
 #include "model/DescribeLiveDomainTranscodeDataResult.h"
 #include "model/DescribeLiveLazyPullStreamConfigRequest.h"
 #include "model/DescribeLiveLazyPullStreamConfigResult.h"
-#include "model/DescribeLivePullStreamConfigRequest.h"
-#include "model/DescribeLivePullStreamConfigResult.h"
 #include "model/DescribeLiveRealtimeDeliveryAccRequest.h"
 #include "model/DescribeLiveRealtimeDeliveryAccResult.h"
 #include "model/DescribeLiveRealtimeLogAuthorizedRequest.h"
@@ -487,6 +493,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::AddLiveStreamTranscodeResult> AddLiveStreamTranscodeOutcome;
 			typedef std::future<AddLiveStreamTranscodeOutcome> AddLiveStreamTranscodeOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::AddLiveStreamTranscodeRequest&, const AddLiveStreamTranscodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLiveStreamTranscodeAsyncHandler;
+			typedef Outcome<Error, Model::AddRtsLiveStreamTranscodeResult> AddRtsLiveStreamTranscodeOutcome;
+			typedef std::future<AddRtsLiveStreamTranscodeOutcome> AddRtsLiveStreamTranscodeOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::AddRtsLiveStreamTranscodeRequest&, const AddRtsLiveStreamTranscodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddRtsLiveStreamTranscodeAsyncHandler;
 			typedef Outcome<Error, Model::AddTrancodeSEIResult> AddTrancodeSEIOutcome;
 			typedef std::future<AddTrancodeSEIOutcome> AddTrancodeSEIOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::AddTrancodeSEIRequest&, const AddTrancodeSEIOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddTrancodeSEIAsyncHandler;
@@ -694,6 +703,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLiveDomainBpsDataByTimeStampResult> DescribeLiveDomainBpsDataByTimeStampOutcome;
 			typedef std::future<DescribeLiveDomainBpsDataByTimeStampOutcome> DescribeLiveDomainBpsDataByTimeStampOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainBpsDataByTimeStampRequest&, const DescribeLiveDomainBpsDataByTimeStampOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainBpsDataByTimeStampAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLiveDomainCertificateInfoResult> DescribeLiveDomainCertificateInfoOutcome;
+			typedef std::future<DescribeLiveDomainCertificateInfoOutcome> DescribeLiveDomainCertificateInfoOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainCertificateInfoRequest&, const DescribeLiveDomainCertificateInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainCertificateInfoAsyncHandler;
 			typedef Outcome<Error, Model::DescribeLiveDomainConfigsResult> DescribeLiveDomainConfigsOutcome;
 			typedef std::future<DescribeLiveDomainConfigsOutcome> DescribeLiveDomainConfigsOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainConfigsRequest&, const DescribeLiveDomainConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainConfigsAsyncHandler;
@@ -703,6 +715,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLiveDomainFrameRateAndBitRateDataResult> DescribeLiveDomainFrameRateAndBitRateDataOutcome;
 			typedef std::future<DescribeLiveDomainFrameRateAndBitRateDataOutcome> DescribeLiveDomainFrameRateAndBitRateDataOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainFrameRateAndBitRateDataRequest&, const DescribeLiveDomainFrameRateAndBitRateDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainFrameRateAndBitRateDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLiveDomainLimitResult> DescribeLiveDomainLimitOutcome;
+			typedef std::future<DescribeLiveDomainLimitOutcome> DescribeLiveDomainLimitOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainLimitRequest&, const DescribeLiveDomainLimitOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainLimitAsyncHandler;
 			typedef Outcome<Error, Model::DescribeLiveDomainMappingResult> DescribeLiveDomainMappingOutcome;
 			typedef std::future<DescribeLiveDomainMappingOutcome> DescribeLiveDomainMappingOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainMappingRequest&, const DescribeLiveDomainMappingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainMappingAsyncHandler;
@@ -733,6 +748,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLiveDomainSnapshotDataResult> DescribeLiveDomainSnapshotDataOutcome;
 			typedef std::future<DescribeLiveDomainSnapshotDataOutcome> DescribeLiveDomainSnapshotDataOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainSnapshotDataRequest&, const DescribeLiveDomainSnapshotDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainSnapshotDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLiveDomainTimeShiftDataResult> DescribeLiveDomainTimeShiftDataOutcome;
+			typedef std::future<DescribeLiveDomainTimeShiftDataOutcome> DescribeLiveDomainTimeShiftDataOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainTimeShiftDataRequest&, const DescribeLiveDomainTimeShiftDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainTimeShiftDataAsyncHandler;
 			typedef Outcome<Error, Model::DescribeLiveDomainTrafficDataResult> DescribeLiveDomainTrafficDataOutcome;
 			typedef std::future<DescribeLiveDomainTrafficDataOutcome> DescribeLiveDomainTrafficDataOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainTrafficDataRequest&, const DescribeLiveDomainTrafficDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainTrafficDataAsyncHandler;
@@ -742,9 +760,6 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLiveLazyPullStreamConfigResult> DescribeLiveLazyPullStreamConfigOutcome;
 			typedef std::future<DescribeLiveLazyPullStreamConfigOutcome> DescribeLiveLazyPullStreamConfigOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveLazyPullStreamConfigRequest&, const DescribeLiveLazyPullStreamConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveLazyPullStreamConfigAsyncHandler;
-			typedef Outcome<Error, Model::DescribeLivePullStreamConfigResult> DescribeLivePullStreamConfigOutcome;
-			typedef std::future<DescribeLivePullStreamConfigOutcome> DescribeLivePullStreamConfigOutcomeCallable;
-			typedef std::function<void(const LiveClient*, const Model::DescribeLivePullStreamConfigRequest&, const DescribeLivePullStreamConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLivePullStreamConfigAsyncHandler;
 			typedef Outcome<Error, Model::DescribeLiveRealtimeDeliveryAccResult> DescribeLiveRealtimeDeliveryAccOutcome;
 			typedef std::future<DescribeLiveRealtimeDeliveryAccOutcome> DescribeLiveRealtimeDeliveryAccOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveRealtimeDeliveryAccRequest&, const DescribeLiveRealtimeDeliveryAccOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveRealtimeDeliveryAccAsyncHandler;
@@ -1086,6 +1101,9 @@ namespace AlibabaCloud
 			AddLiveStreamTranscodeOutcome addLiveStreamTranscode(const Model::AddLiveStreamTranscodeRequest &request)const;
 			void addLiveStreamTranscodeAsync(const Model::AddLiveStreamTranscodeRequest& request, const AddLiveStreamTranscodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddLiveStreamTranscodeOutcomeCallable addLiveStreamTranscodeCallable(const Model::AddLiveStreamTranscodeRequest& request) const;
+			AddRtsLiveStreamTranscodeOutcome addRtsLiveStreamTranscode(const Model::AddRtsLiveStreamTranscodeRequest &request)const;
+			void addRtsLiveStreamTranscodeAsync(const Model::AddRtsLiveStreamTranscodeRequest& request, const AddRtsLiveStreamTranscodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddRtsLiveStreamTranscodeOutcomeCallable addRtsLiveStreamTranscodeCallable(const Model::AddRtsLiveStreamTranscodeRequest& request) const;
 			AddTrancodeSEIOutcome addTrancodeSEI(const Model::AddTrancodeSEIRequest &request)const;
 			void addTrancodeSEIAsync(const Model::AddTrancodeSEIRequest& request, const AddTrancodeSEIAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddTrancodeSEIOutcomeCallable addTrancodeSEICallable(const Model::AddTrancodeSEIRequest& request) const;
@@ -1293,6 +1311,9 @@ namespace AlibabaCloud
 			DescribeLiveDomainBpsDataByTimeStampOutcome describeLiveDomainBpsDataByTimeStamp(const Model::DescribeLiveDomainBpsDataByTimeStampRequest &request)const;
 			void describeLiveDomainBpsDataByTimeStampAsync(const Model::DescribeLiveDomainBpsDataByTimeStampRequest& request, const DescribeLiveDomainBpsDataByTimeStampAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveDomainBpsDataByTimeStampOutcomeCallable describeLiveDomainBpsDataByTimeStampCallable(const Model::DescribeLiveDomainBpsDataByTimeStampRequest& request) const;
+			DescribeLiveDomainCertificateInfoOutcome describeLiveDomainCertificateInfo(const Model::DescribeLiveDomainCertificateInfoRequest &request)const;
+			void describeLiveDomainCertificateInfoAsync(const Model::DescribeLiveDomainCertificateInfoRequest& request, const DescribeLiveDomainCertificateInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLiveDomainCertificateInfoOutcomeCallable describeLiveDomainCertificateInfoCallable(const Model::DescribeLiveDomainCertificateInfoRequest& request) const;
 			DescribeLiveDomainConfigsOutcome describeLiveDomainConfigs(const Model::DescribeLiveDomainConfigsRequest &request)const;
 			void describeLiveDomainConfigsAsync(const Model::DescribeLiveDomainConfigsRequest& request, const DescribeLiveDomainConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveDomainConfigsOutcomeCallable describeLiveDomainConfigsCallable(const Model::DescribeLiveDomainConfigsRequest& request) const;
@@ -1302,6 +1323,9 @@ namespace AlibabaCloud
 			DescribeLiveDomainFrameRateAndBitRateDataOutcome describeLiveDomainFrameRateAndBitRateData(const Model::DescribeLiveDomainFrameRateAndBitRateDataRequest &request)const;
 			void describeLiveDomainFrameRateAndBitRateDataAsync(const Model::DescribeLiveDomainFrameRateAndBitRateDataRequest& request, const DescribeLiveDomainFrameRateAndBitRateDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveDomainFrameRateAndBitRateDataOutcomeCallable describeLiveDomainFrameRateAndBitRateDataCallable(const Model::DescribeLiveDomainFrameRateAndBitRateDataRequest& request) const;
+			DescribeLiveDomainLimitOutcome describeLiveDomainLimit(const Model::DescribeLiveDomainLimitRequest &request)const;
+			void describeLiveDomainLimitAsync(const Model::DescribeLiveDomainLimitRequest& request, const DescribeLiveDomainLimitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLiveDomainLimitOutcomeCallable describeLiveDomainLimitCallable(const Model::DescribeLiveDomainLimitRequest& request) const;
 			DescribeLiveDomainMappingOutcome describeLiveDomainMapping(const Model::DescribeLiveDomainMappingRequest &request)const;
 			void describeLiveDomainMappingAsync(const Model::DescribeLiveDomainMappingRequest& request, const DescribeLiveDomainMappingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveDomainMappingOutcomeCallable describeLiveDomainMappingCallable(const Model::DescribeLiveDomainMappingRequest& request) const;
@@ -1332,6 +1356,9 @@ namespace AlibabaCloud
 			DescribeLiveDomainSnapshotDataOutcome describeLiveDomainSnapshotData(const Model::DescribeLiveDomainSnapshotDataRequest &request)const;
 			void describeLiveDomainSnapshotDataAsync(const Model::DescribeLiveDomainSnapshotDataRequest& request, const DescribeLiveDomainSnapshotDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveDomainSnapshotDataOutcomeCallable describeLiveDomainSnapshotDataCallable(const Model::DescribeLiveDomainSnapshotDataRequest& request) const;
+			DescribeLiveDomainTimeShiftDataOutcome describeLiveDomainTimeShiftData(const Model::DescribeLiveDomainTimeShiftDataRequest &request)const;
+			void describeLiveDomainTimeShiftDataAsync(const Model::DescribeLiveDomainTimeShiftDataRequest& request, const DescribeLiveDomainTimeShiftDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLiveDomainTimeShiftDataOutcomeCallable describeLiveDomainTimeShiftDataCallable(const Model::DescribeLiveDomainTimeShiftDataRequest& request) const;
 			DescribeLiveDomainTrafficDataOutcome describeLiveDomainTrafficData(const Model::DescribeLiveDomainTrafficDataRequest &request)const;
 			void describeLiveDomainTrafficDataAsync(const Model::DescribeLiveDomainTrafficDataRequest& request, const DescribeLiveDomainTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveDomainTrafficDataOutcomeCallable describeLiveDomainTrafficDataCallable(const Model::DescribeLiveDomainTrafficDataRequest& request) const;
@@ -1341,9 +1368,6 @@ namespace AlibabaCloud
 			DescribeLiveLazyPullStreamConfigOutcome describeLiveLazyPullStreamConfig(const Model::DescribeLiveLazyPullStreamConfigRequest &request)const;
 			void describeLiveLazyPullStreamConfigAsync(const Model::DescribeLiveLazyPullStreamConfigRequest& request, const DescribeLiveLazyPullStreamConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveLazyPullStreamConfigOutcomeCallable describeLiveLazyPullStreamConfigCallable(const Model::DescribeLiveLazyPullStreamConfigRequest& request) const;
-			DescribeLivePullStreamConfigOutcome describeLivePullStreamConfig(const Model::DescribeLivePullStreamConfigRequest &request)const;
-			void describeLivePullStreamConfigAsync(const Model::DescribeLivePullStreamConfigRequest& request, const DescribeLivePullStreamConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeLivePullStreamConfigOutcomeCallable describeLivePullStreamConfigCallable(const Model::DescribeLivePullStreamConfigRequest& request) const;
 			DescribeLiveRealtimeDeliveryAccOutcome describeLiveRealtimeDeliveryAcc(const Model::DescribeLiveRealtimeDeliveryAccRequest &request)const;
 			void describeLiveRealtimeDeliveryAccAsync(const Model::DescribeLiveRealtimeDeliveryAccRequest& request, const DescribeLiveRealtimeDeliveryAccAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveRealtimeDeliveryAccOutcomeCallable describeLiveRealtimeDeliveryAccCallable(const Model::DescribeLiveRealtimeDeliveryAccRequest& request) const;

live/include/alibabacloud/live/model/AddLiveAppSnapshotConfigRequest.h

@@ -53,6 +53,8 @@ namespace AlibabaCloud
 				void setSequenceOssObject(const std::string& sequenceOssObject);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
+				std::string getCallback()const;
+				void setCallback(const std::string& callback);
 
             private:
 				int timeInterval_;
@@ -64,6 +66,7 @@ namespace AlibabaCloud
 				std::string domainName_;
 				std::string sequenceOssObject_;
 				long ownerId_;
+				std::string callback_;
 
 			};
 		}

live/include/alibabacloud/live/model/AddLivePullStreamInfoConfigRequest.h

@@ -41,6 +41,8 @@ namespace AlibabaCloud
 				void setAppName(const std::string& appName);
 				std::string getStreamName()const;
 				void setStreamName(const std::string& streamName);
+				std::string getPullAlways()const;
+				void setPullAlways(const std::string& pullAlways);
 				std::string getDomainName()const;
 				void setDomainName(const std::string& domainName);
 				std::string getEndTime()const;
@@ -54,6 +56,7 @@ namespace AlibabaCloud
 				std::string startTime_;
 				std::string appName_;
 				std::string streamName_;
+				std::string pullAlways_;
 				std::string domainName_;
 				std::string endTime_;
 				long ownerId_;

live/include/alibabacloud/live/model/AddRtsLiveStreamTranscodeRequest.h

@@ -0,0 +1,99 @@
+/*
+ * 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_LIVE_MODEL_ADDRTSLIVESTREAMTRANSCODEREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_ADDRTSLIVESTREAMTRANSCODEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/live/LiveExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Live
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LIVE_EXPORT AddRtsLiveStreamTranscodeRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddRtsLiveStreamTranscodeRequest();
+				~AddRtsLiveStreamTranscodeRequest();
+
+				std::string get_Template()const;
+				void set_Template(const std::string& _template);
+				bool getDeleteBframes()const;
+				void setDeleteBframes(bool deleteBframes);
+				std::string getGop()const;
+				void setGop(const std::string& gop);
+				bool getOpus()const;
+				void setOpus(bool opus);
+				std::string getAudioCodec()const;
+				void setAudioCodec(const std::string& audioCodec);
+				std::string getTemplateType()const;
+				void setTemplateType(const std::string& templateType);
+				std::string getAudioProfile()const;
+				void setAudioProfile(const std::string& audioProfile);
+				int getHeight()const;
+				void setHeight(int height);
+				std::string getApp()const;
+				void setApp(const std::string& app);
+				int getAudioChannelNum()const;
+				void setAudioChannelNum(int audioChannelNum);
+				int getProfile()const;
+				void setProfile(int profile);
+				int getFPS()const;
+				void setFPS(int fPS);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				int getAudioRate()const;
+				void setAudioRate(int audioRate);
+				int getAudioBitrate()const;
+				void setAudioBitrate(int audioBitrate);
+				std::string getDomain()const;
+				void setDomain(const std::string& domain);
+				int getWidth()const;
+				void setWidth(int width);
+				int getVideoBitrate()const;
+				void setVideoBitrate(int videoBitrate);
+
+            private:
+				std::string _template_;
+				bool deleteBframes_;
+				std::string gop_;
+				bool opus_;
+				std::string audioCodec_;
+				std::string templateType_;
+				std::string audioProfile_;
+				int height_;
+				std::string app_;
+				int audioChannelNum_;
+				int profile_;
+				int fPS_;
+				long ownerId_;
+				int audioRate_;
+				int audioBitrate_;
+				std::string domain_;
+				int width_;
+				int videoBitrate_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_ADDRTSLIVESTREAMTRANSCODEREQUEST_H_

live/include/alibabacloud/live/model/AddRtsLiveStreamTranscodeResult.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_LIVE_MODEL_ADDRTSLIVESTREAMTRANSCODERESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_ADDRTSLIVESTREAMTRANSCODERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/live/LiveExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Live
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LIVE_EXPORT AddRtsLiveStreamTranscodeResult : public ServiceResult
+			{
+			public:
+
+
+				AddRtsLiveStreamTranscodeResult();
+				explicit AddRtsLiveStreamTranscodeResult(const std::string &payload);
+				~AddRtsLiveStreamTranscodeResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_ADDRTSLIVESTREAMTRANSCODERESULT_H_

live/include/alibabacloud/live/model/DescribeLiveDomainCertificateInfoRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPULLSTREAMCONFIGREQUEST_H_
-#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPULLSTREAMCONFIGREQUEST_H_
+#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINCERTIFICATEINFOREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINCERTIFICATEINFOREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,27 +28,24 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_LIVE_EXPORT DescribeLivePullStreamConfigRequest : public RpcServiceRequest
+			class ALIBABACLOUD_LIVE_EXPORT DescribeLiveDomainCertificateInfoRequest : public RpcServiceRequest
 			{
 
 			public:
-				DescribeLivePullStreamConfigRequest();
-				~DescribeLivePullStreamConfigRequest();
+				DescribeLiveDomainCertificateInfoRequest();
+				~DescribeLiveDomainCertificateInfoRequest();
 
 				std::string getDomainName()const;
 				void setDomainName(const std::string& domainName);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
-				std::string getSecurityToken()const;
-				void setSecurityToken(const std::string& securityToken);
 
             private:
 				std::string domainName_;
 				long ownerId_;
-				std::string securityToken_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPULLSTREAMCONFIGREQUEST_H_
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINCERTIFICATEINFOREQUEST_H_

live/include/alibabacloud/live/model/DescribeLiveDomainCertificateInfoResult.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_LIVE_MODEL_DESCRIBELIVEDOMAINCERTIFICATEINFORESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINCERTIFICATEINFORESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/live/LiveExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Live
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LIVE_EXPORT DescribeLiveDomainCertificateInfoResult : public ServiceResult
+			{
+			public:
+				struct CertInfo
+				{
+					std::string status;
+					std::string certLife;
+					std::string domainName;
+					std::string sSLPub;
+					std::string certDomainName;
+					std::string certOrg;
+					std::string certType;
+					std::string certExpireTime;
+					std::string certName;
+					std::string sSLProtocol;
+				};
+
+
+				DescribeLiveDomainCertificateInfoResult();
+				explicit DescribeLiveDomainCertificateInfoResult(const std::string &payload);
+				~DescribeLiveDomainCertificateInfoResult();
+				std::vector<CertInfo> getCertInfos()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<CertInfo> certInfos_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINCERTIFICATEINFORESULT_H_

live/include/alibabacloud/live/model/DescribeLiveDomainLimitRequest.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_LIVE_MODEL_DESCRIBELIVEDOMAINLIMITREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINLIMITREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/live/LiveExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Live
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LIVE_EXPORT DescribeLiveDomainLimitRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeLiveDomainLimitRequest();
+				~DescribeLiveDomainLimitRequest();
+
+				std::string getLiveapiRequestFrom()const;
+				void setLiveapiRequestFrom(const std::string& liveapiRequestFrom);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				std::string liveapiRequestFrom_;
+				std::string domainName_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINLIMITREQUEST_H_

live/include/alibabacloud/live/model/DescribeLiveDomainLimitResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPULLSTREAMCONFIGRESULT_H_
-#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPULLSTREAMCONFIGRESULT_H_
+#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINLIMITRESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINLIMITRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,32 +29,29 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_LIVE_EXPORT DescribeLivePullStreamConfigResult : public ServiceResult
+			class ALIBABACLOUD_LIVE_EXPORT DescribeLiveDomainLimitResult : public ServiceResult
 			{
 			public:
-				struct LiveAppRecord
+				struct LiveDomainLimit
 				{
-					std::string sourceUrl;
-					std::string streamName;
-					std::string endTime;
+					int limitTranscodeNum;
 					std::string domainName;
-					std::string startTime;
-					std::string appName;
+					int limitNum;
 				};
 
 
-				DescribeLivePullStreamConfigResult();
-				explicit DescribeLivePullStreamConfigResult(const std::string &payload);
-				~DescribeLivePullStreamConfigResult();
-				std::vector<LiveAppRecord> getLiveAppRecordList()const;
+				DescribeLiveDomainLimitResult();
+				explicit DescribeLiveDomainLimitResult(const std::string &payload);
+				~DescribeLiveDomainLimitResult();
+				std::vector<LiveDomainLimit> getLiveDomainLimitList()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::vector<LiveAppRecord> liveAppRecordList_;
+				std::vector<LiveDomainLimit> liveDomainLimitList_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPULLSTREAMCONFIGRESULT_H_
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINLIMITRESULT_H_

live/include/alibabacloud/live/model/DescribeLiveDomainTimeShiftDataRequest.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_LIVE_MODEL_DESCRIBELIVEDOMAINTIMESHIFTDATAREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINTIMESHIFTDATAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/live/LiveExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Live
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LIVE_EXPORT DescribeLiveDomainTimeShiftDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeLiveDomainTimeShiftDataRequest();
+				~DescribeLiveDomainTimeShiftDataRequest();
+
+				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);
+				std::string getInterval()const;
+				void setInterval(const std::string& interval);
+
+            private:
+				std::string startTime_;
+				std::string domainName_;
+				std::string endTime_;
+				long ownerId_;
+				std::string interval_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINTIMESHIFTDATAREQUEST_H_

live/include/alibabacloud/live/model/DescribeLiveDomainTimeShiftDataResult.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_LIVE_MODEL_DESCRIBELIVEDOMAINTIMESHIFTDATARESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINTIMESHIFTDATARESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/live/LiveExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Live
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LIVE_EXPORT DescribeLiveDomainTimeShiftDataResult : public ServiceResult
+			{
+			public:
+				struct DataModule
+				{
+					std::string type;
+					std::string size;
+					std::string timeStamp;
+				};
+
+
+				DescribeLiveDomainTimeShiftDataResult();
+				explicit DescribeLiveDomainTimeShiftDataResult(const std::string &payload);
+				~DescribeLiveDomainTimeShiftDataResult();
+				std::vector<DataModule> getTimeShiftData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<DataModule> timeShiftData_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINTIMESHIFTDATARESULT_H_

live/include/alibabacloud/live/model/DescribeLiveSnapshotConfigResult.h

@@ -36,6 +36,7 @@ namespace AlibabaCloud
 				{
 					std::string overwriteOssObject;
 					std::string sequenceOssObject;
+					std::string callback;
 					int timeInterval;
 					std::string ossEndpoint;
 					std::string domainName;

live/include/alibabacloud/live/model/DescribeLiveStreamTranscodeInfoResult.h

@@ -36,14 +36,16 @@ namespace AlibabaCloud
 				{
 					struct CustomTranscodeParameters
 					{
-						int audioBitrate;
 						int fPS;
-						std::string audioProfile;
 						std::string gop;
+						std::string templateType;
+						int audioBitrate;
+						std::string bframes;
+						std::string audioProfile;
+						std::string rtsFlag;
 						int height;
 						std::string videoProfile;
 						int audioChannelNum;
-						std::string templateType;
 						int width;
 						std::string audioCodec;
 						int audioRate;

live/include/alibabacloud/live/model/UnTagLiveResourcesRequest.h

@@ -35,6 +35,8 @@ namespace AlibabaCloud
 				UnTagLiveResourcesRequest();
 				~UnTagLiveResourcesRequest();
 
+				bool getAll()const;
+				void setAll(bool all);
 				std::vector<std::string> getResourceId()const;
 				void setResourceId(const std::vector<std::string>& resourceId);
 				long getOwnerId()const;
@@ -45,6 +47,7 @@ namespace AlibabaCloud
 				void setTagKey(const std::vector<std::string>& tagKey);
 
             private:
+				bool all_;
 				std::vector<std::string> resourceId_;
 				long ownerId_;
 				std::string resourceType_;

live/include/alibabacloud/live/model/UpdateLiveAppSnapshotConfigRequest.h

@@ -53,6 +53,8 @@ namespace AlibabaCloud
 				void setSequenceOssObject(const std::string& sequenceOssObject);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
+				std::string getCallback()const;
+				void setCallback(const std::string& callback);
 
             private:
 				int timeInterval_;
@@ -64,6 +66,7 @@ namespace AlibabaCloud
 				std::string domainName_;
 				std::string sequenceOssObject_;
 				long ownerId_;
+				std::string callback_;
 
 			};
 		}

live/src/LiveClient.cc

@@ -31,21 +31,21 @@ LiveClient::LiveClient(const Credentials &credentials, const ClientConfiguration
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "live");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 LiveClient::LiveClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "live");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 LiveClient::LiveClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "live");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 LiveClient::~LiveClient()
@@ -771,6 +771,42 @@ LiveClient::AddLiveStreamTranscodeOutcomeCallable LiveClient::addLiveStreamTrans
 	return task->get_future();
 }
 
+LiveClient::AddRtsLiveStreamTranscodeOutcome LiveClient::addRtsLiveStreamTranscode(const AddRtsLiveStreamTranscodeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddRtsLiveStreamTranscodeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddRtsLiveStreamTranscodeOutcome(AddRtsLiveStreamTranscodeResult(outcome.result()));
+	else
+		return AddRtsLiveStreamTranscodeOutcome(outcome.error());
+}
+
+void LiveClient::addRtsLiveStreamTranscodeAsync(const AddRtsLiveStreamTranscodeRequest& request, const AddRtsLiveStreamTranscodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addRtsLiveStreamTranscode(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::AddRtsLiveStreamTranscodeOutcomeCallable LiveClient::addRtsLiveStreamTranscodeCallable(const AddRtsLiveStreamTranscodeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddRtsLiveStreamTranscodeOutcome()>>(
+			[this, request]()
+			{
+			return this->addRtsLiveStreamTranscode(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::AddTrancodeSEIOutcome LiveClient::addTrancodeSEI(const AddTrancodeSEIRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3255,6 +3291,42 @@ LiveClient::DescribeLiveDomainBpsDataByTimeStampOutcomeCallable LiveClient::desc
 	return task->get_future();
 }
 
+LiveClient::DescribeLiveDomainCertificateInfoOutcome LiveClient::describeLiveDomainCertificateInfo(const DescribeLiveDomainCertificateInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLiveDomainCertificateInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLiveDomainCertificateInfoOutcome(DescribeLiveDomainCertificateInfoResult(outcome.result()));
+	else
+		return DescribeLiveDomainCertificateInfoOutcome(outcome.error());
+}
+
+void LiveClient::describeLiveDomainCertificateInfoAsync(const DescribeLiveDomainCertificateInfoRequest& request, const DescribeLiveDomainCertificateInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLiveDomainCertificateInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DescribeLiveDomainCertificateInfoOutcomeCallable LiveClient::describeLiveDomainCertificateInfoCallable(const DescribeLiveDomainCertificateInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLiveDomainCertificateInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLiveDomainCertificateInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DescribeLiveDomainConfigsOutcome LiveClient::describeLiveDomainConfigs(const DescribeLiveDomainConfigsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3363,6 +3435,42 @@ LiveClient::DescribeLiveDomainFrameRateAndBitRateDataOutcomeCallable LiveClient:
 	return task->get_future();
 }
 
+LiveClient::DescribeLiveDomainLimitOutcome LiveClient::describeLiveDomainLimit(const DescribeLiveDomainLimitRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLiveDomainLimitOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLiveDomainLimitOutcome(DescribeLiveDomainLimitResult(outcome.result()));
+	else
+		return DescribeLiveDomainLimitOutcome(outcome.error());
+}
+
+void LiveClient::describeLiveDomainLimitAsync(const DescribeLiveDomainLimitRequest& request, const DescribeLiveDomainLimitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLiveDomainLimit(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DescribeLiveDomainLimitOutcomeCallable LiveClient::describeLiveDomainLimitCallable(const DescribeLiveDomainLimitRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLiveDomainLimitOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLiveDomainLimit(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DescribeLiveDomainMappingOutcome LiveClient::describeLiveDomainMapping(const DescribeLiveDomainMappingRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3723,6 +3831,42 @@ LiveClient::DescribeLiveDomainSnapshotDataOutcomeCallable LiveClient::describeLi
 	return task->get_future();
 }
 
+LiveClient::DescribeLiveDomainTimeShiftDataOutcome LiveClient::describeLiveDomainTimeShiftData(const DescribeLiveDomainTimeShiftDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLiveDomainTimeShiftDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLiveDomainTimeShiftDataOutcome(DescribeLiveDomainTimeShiftDataResult(outcome.result()));
+	else
+		return DescribeLiveDomainTimeShiftDataOutcome(outcome.error());
+}
+
+void LiveClient::describeLiveDomainTimeShiftDataAsync(const DescribeLiveDomainTimeShiftDataRequest& request, const DescribeLiveDomainTimeShiftDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLiveDomainTimeShiftData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DescribeLiveDomainTimeShiftDataOutcomeCallable LiveClient::describeLiveDomainTimeShiftDataCallable(const DescribeLiveDomainTimeShiftDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLiveDomainTimeShiftDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLiveDomainTimeShiftData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DescribeLiveDomainTrafficDataOutcome LiveClient::describeLiveDomainTrafficData(const DescribeLiveDomainTrafficDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3831,42 +3975,6 @@ LiveClient::DescribeLiveLazyPullStreamConfigOutcomeCallable LiveClient::describe
 	return task->get_future();
 }
 
-LiveClient::DescribeLivePullStreamConfigOutcome LiveClient::describeLivePullStreamConfig(const DescribeLivePullStreamConfigRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DescribeLivePullStreamConfigOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DescribeLivePullStreamConfigOutcome(DescribeLivePullStreamConfigResult(outcome.result()));
-	else
-		return DescribeLivePullStreamConfigOutcome(outcome.error());
-}
-
-void LiveClient::describeLivePullStreamConfigAsync(const DescribeLivePullStreamConfigRequest& request, const DescribeLivePullStreamConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, describeLivePullStreamConfig(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-LiveClient::DescribeLivePullStreamConfigOutcomeCallable LiveClient::describeLivePullStreamConfigCallable(const DescribeLivePullStreamConfigRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DescribeLivePullStreamConfigOutcome()>>(
-			[this, request]()
-			{
-			return this->describeLivePullStreamConfig(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 LiveClient::DescribeLiveRealtimeDeliveryAccOutcome LiveClient::describeLiveRealtimeDeliveryAcc(const DescribeLiveRealtimeDeliveryAccRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

live/src/model/AddLiveAppSnapshotConfigRequest.cc

@@ -126,3 +126,14 @@ void AddLiveAppSnapshotConfigRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
+std::string AddLiveAppSnapshotConfigRequest::getCallback()const
+{
+	return callback_;
+}
+
+void AddLiveAppSnapshotConfigRequest::setCallback(const std::string& callback)
+{
+	callback_ = callback;
+	setParameter("Callback", callback);
+}
+

live/src/model/AddLivePullStreamInfoConfigRequest.cc

@@ -60,6 +60,17 @@ void AddLivePullStreamInfoConfigRequest::setStreamName(const std::string& stream
 	setParameter("StreamName", streamName);
 }
 
+std::string AddLivePullStreamInfoConfigRequest::getPullAlways()const
+{
+	return pullAlways_;
+}
+
+void AddLivePullStreamInfoConfigRequest::setPullAlways(const std::string& pullAlways)
+{
+	pullAlways_ = pullAlways;
+	setParameter("PullAlways", pullAlways);
+}
+
 std::string AddLivePullStreamInfoConfigRequest::getDomainName()const
 {
 	return domainName_;

live/src/model/AddRtsLiveStreamTranscodeRequest.cc

@@ -0,0 +1,227 @@
+/*
+ * 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/live/model/AddRtsLiveStreamTranscodeRequest.h>
+
+using AlibabaCloud::Live::Model::AddRtsLiveStreamTranscodeRequest;
+
+AddRtsLiveStreamTranscodeRequest::AddRtsLiveStreamTranscodeRequest() :
+	RpcServiceRequest("live", "2016-11-01", "AddRtsLiveStreamTranscode")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AddRtsLiveStreamTranscodeRequest::~AddRtsLiveStreamTranscodeRequest()
+{}
+
+std::string AddRtsLiveStreamTranscodeRequest::get_Template()const
+{
+	return _template_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::set_Template(const std::string& _template)
+{
+	_template_ = _template;
+	setParameter("_Template", _template);
+}
+
+bool AddRtsLiveStreamTranscodeRequest::getDeleteBframes()const
+{
+	return deleteBframes_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setDeleteBframes(bool deleteBframes)
+{
+	deleteBframes_ = deleteBframes;
+	setParameter("DeleteBframes", deleteBframes ? "true" : "false");
+}
+
+std::string AddRtsLiveStreamTranscodeRequest::getGop()const
+{
+	return gop_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setGop(const std::string& gop)
+{
+	gop_ = gop;
+	setParameter("Gop", gop);
+}
+
+bool AddRtsLiveStreamTranscodeRequest::getOpus()const
+{
+	return opus_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setOpus(bool opus)
+{
+	opus_ = opus;
+	setParameter("Opus", opus ? "true" : "false");
+}
+
+std::string AddRtsLiveStreamTranscodeRequest::getAudioCodec()const
+{
+	return audioCodec_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setAudioCodec(const std::string& audioCodec)
+{
+	audioCodec_ = audioCodec;
+	setParameter("AudioCodec", audioCodec);
+}
+
+std::string AddRtsLiveStreamTranscodeRequest::getTemplateType()const
+{
+	return templateType_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setTemplateType(const std::string& templateType)
+{
+	templateType_ = templateType;
+	setParameter("TemplateType", templateType);
+}
+
+std::string AddRtsLiveStreamTranscodeRequest::getAudioProfile()const
+{
+	return audioProfile_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setAudioProfile(const std::string& audioProfile)
+{
+	audioProfile_ = audioProfile;
+	setParameter("AudioProfile", audioProfile);
+}
+
+int AddRtsLiveStreamTranscodeRequest::getHeight()const
+{
+	return height_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setHeight(int height)
+{
+	height_ = height;
+	setParameter("Height", std::to_string(height));
+}
+
+std::string AddRtsLiveStreamTranscodeRequest::getApp()const
+{
+	return app_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setApp(const std::string& app)
+{
+	app_ = app;
+	setParameter("App", app);
+}
+
+int AddRtsLiveStreamTranscodeRequest::getAudioChannelNum()const
+{
+	return audioChannelNum_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setAudioChannelNum(int audioChannelNum)
+{
+	audioChannelNum_ = audioChannelNum;
+	setParameter("AudioChannelNum", std::to_string(audioChannelNum));
+}
+
+int AddRtsLiveStreamTranscodeRequest::getProfile()const
+{
+	return profile_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setProfile(int profile)
+{
+	profile_ = profile;
+	setParameter("Profile", std::to_string(profile));
+}
+
+int AddRtsLiveStreamTranscodeRequest::getFPS()const
+{
+	return fPS_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setFPS(int fPS)
+{
+	fPS_ = fPS;
+	setParameter("FPS", std::to_string(fPS));
+}
+
+long AddRtsLiveStreamTranscodeRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+int AddRtsLiveStreamTranscodeRequest::getAudioRate()const
+{
+	return audioRate_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setAudioRate(int audioRate)
+{
+	audioRate_ = audioRate;
+	setParameter("AudioRate", std::to_string(audioRate));
+}
+
+int AddRtsLiveStreamTranscodeRequest::getAudioBitrate()const
+{
+	return audioBitrate_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setAudioBitrate(int audioBitrate)
+{
+	audioBitrate_ = audioBitrate;
+	setParameter("AudioBitrate", std::to_string(audioBitrate));
+}
+
+std::string AddRtsLiveStreamTranscodeRequest::getDomain()const
+{
+	return domain_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setDomain(const std::string& domain)
+{
+	domain_ = domain;
+	setParameter("Domain", domain);
+}
+
+int AddRtsLiveStreamTranscodeRequest::getWidth()const
+{
+	return width_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setWidth(int width)
+{
+	width_ = width;
+	setParameter("Width", std::to_string(width));
+}
+
+int AddRtsLiveStreamTranscodeRequest::getVideoBitrate()const
+{
+	return videoBitrate_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setVideoBitrate(int videoBitrate)
+{
+	videoBitrate_ = videoBitrate;
+	setParameter("VideoBitrate", std::to_string(videoBitrate));
+}
+

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

live/src/model/DescribeLiveDomainCertificateInfoRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/live/model/DescribeLiveDomainCertificateInfoRequest.h>
+
+using AlibabaCloud::Live::Model::DescribeLiveDomainCertificateInfoRequest;
+
+DescribeLiveDomainCertificateInfoRequest::DescribeLiveDomainCertificateInfoRequest() :
+	RpcServiceRequest("live", "2016-11-01", "DescribeLiveDomainCertificateInfo")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeLiveDomainCertificateInfoRequest::~DescribeLiveDomainCertificateInfoRequest()
+{}
+
+std::string DescribeLiveDomainCertificateInfoRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeLiveDomainCertificateInfoRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long DescribeLiveDomainCertificateInfoRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeLiveDomainCertificateInfoRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

live/src/model/DescribeLiveDomainCertificateInfoResult.cc

@@ -0,0 +1,75 @@
+/*
+ * 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/live/model/DescribeLiveDomainCertificateInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLiveDomainCertificateInfoResult::DescribeLiveDomainCertificateInfoResult() :
+	ServiceResult()
+{}
+
+DescribeLiveDomainCertificateInfoResult::DescribeLiveDomainCertificateInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLiveDomainCertificateInfoResult::~DescribeLiveDomainCertificateInfoResult()
+{}
+
+void DescribeLiveDomainCertificateInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allCertInfosNode = value["CertInfos"]["CertInfo"];
+	for (auto valueCertInfosCertInfo : allCertInfosNode)
+	{
+		CertInfo certInfosObject;
+		if(!valueCertInfosCertInfo["DomainName"].isNull())
+			certInfosObject.domainName = valueCertInfosCertInfo["DomainName"].asString();
+		if(!valueCertInfosCertInfo["CertName"].isNull())
+			certInfosObject.certName = valueCertInfosCertInfo["CertName"].asString();
+		if(!valueCertInfosCertInfo["CertDomainName"].isNull())
+			certInfosObject.certDomainName = valueCertInfosCertInfo["CertDomainName"].asString();
+		if(!valueCertInfosCertInfo["CertExpireTime"].isNull())
+			certInfosObject.certExpireTime = valueCertInfosCertInfo["CertExpireTime"].asString();
+		if(!valueCertInfosCertInfo["CertLife"].isNull())
+			certInfosObject.certLife = valueCertInfosCertInfo["CertLife"].asString();
+		if(!valueCertInfosCertInfo["CertOrg"].isNull())
+			certInfosObject.certOrg = valueCertInfosCertInfo["CertOrg"].asString();
+		if(!valueCertInfosCertInfo["CertType"].isNull())
+			certInfosObject.certType = valueCertInfosCertInfo["CertType"].asString();
+		if(!valueCertInfosCertInfo["SSLProtocol"].isNull())
+			certInfosObject.sSLProtocol = valueCertInfosCertInfo["SSLProtocol"].asString();
+		if(!valueCertInfosCertInfo["Status"].isNull())
+			certInfosObject.status = valueCertInfosCertInfo["Status"].asString();
+		if(!valueCertInfosCertInfo["SSLPub"].isNull())
+			certInfosObject.sSLPub = valueCertInfosCertInfo["SSLPub"].asString();
+		certInfos_.push_back(certInfosObject);
+	}
+
+}
+
+std::vector<DescribeLiveDomainCertificateInfoResult::CertInfo> DescribeLiveDomainCertificateInfoResult::getCertInfos()const
+{
+	return certInfos_;
+}
+

live/src/model/DescribeLiveDomainLimitRequest.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/live/model/DescribeLiveDomainLimitRequest.h>
+
+using AlibabaCloud::Live::Model::DescribeLiveDomainLimitRequest;
+
+DescribeLiveDomainLimitRequest::DescribeLiveDomainLimitRequest() :
+	RpcServiceRequest("live", "2016-11-01", "DescribeLiveDomainLimit")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeLiveDomainLimitRequest::~DescribeLiveDomainLimitRequest()
+{}
+
+std::string DescribeLiveDomainLimitRequest::getLiveapiRequestFrom()const
+{
+	return liveapiRequestFrom_;
+}
+
+void DescribeLiveDomainLimitRequest::setLiveapiRequestFrom(const std::string& liveapiRequestFrom)
+{
+	liveapiRequestFrom_ = liveapiRequestFrom;
+	setParameter("LiveapiRequestFrom", liveapiRequestFrom);
+}
+
+std::string DescribeLiveDomainLimitRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeLiveDomainLimitRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long DescribeLiveDomainLimitRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeLiveDomainLimitRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

live/src/model/DescribeLiveDomainLimitResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/live/model/DescribeLiveDomainLimitResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLiveDomainLimitResult::DescribeLiveDomainLimitResult() :
+	ServiceResult()
+{}
+
+DescribeLiveDomainLimitResult::DescribeLiveDomainLimitResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLiveDomainLimitResult::~DescribeLiveDomainLimitResult()
+{}
+
+void DescribeLiveDomainLimitResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allLiveDomainLimitListNode = value["LiveDomainLimitList"]["LiveDomainLimit"];
+	for (auto valueLiveDomainLimitListLiveDomainLimit : allLiveDomainLimitListNode)
+	{
+		LiveDomainLimit liveDomainLimitListObject;
+		if(!valueLiveDomainLimitListLiveDomainLimit["DomainName"].isNull())
+			liveDomainLimitListObject.domainName = valueLiveDomainLimitListLiveDomainLimit["DomainName"].asString();
+		if(!valueLiveDomainLimitListLiveDomainLimit["LimitNum"].isNull())
+			liveDomainLimitListObject.limitNum = std::stoi(valueLiveDomainLimitListLiveDomainLimit["LimitNum"].asString());
+		if(!valueLiveDomainLimitListLiveDomainLimit["LimitTranscodeNum"].isNull())
+			liveDomainLimitListObject.limitTranscodeNum = std::stoi(valueLiveDomainLimitListLiveDomainLimit["LimitTranscodeNum"].asString());
+		liveDomainLimitList_.push_back(liveDomainLimitListObject);
+	}
+
+}
+
+std::vector<DescribeLiveDomainLimitResult::LiveDomainLimit> DescribeLiveDomainLimitResult::getLiveDomainLimitList()const
+{
+	return liveDomainLimitList_;
+}
+

live/src/model/DescribeLiveDomainTimeShiftDataRequest.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/live/model/DescribeLiveDomainTimeShiftDataRequest.h>
+
+using AlibabaCloud::Live::Model::DescribeLiveDomainTimeShiftDataRequest;
+
+DescribeLiveDomainTimeShiftDataRequest::DescribeLiveDomainTimeShiftDataRequest() :
+	RpcServiceRequest("live", "2016-11-01", "DescribeLiveDomainTimeShiftData")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeLiveDomainTimeShiftDataRequest::~DescribeLiveDomainTimeShiftDataRequest()
+{}
+
+std::string DescribeLiveDomainTimeShiftDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeLiveDomainTimeShiftDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeLiveDomainTimeShiftDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeLiveDomainTimeShiftDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeLiveDomainTimeShiftDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeLiveDomainTimeShiftDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+long DescribeLiveDomainTimeShiftDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeLiveDomainTimeShiftDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeLiveDomainTimeShiftDataRequest::getInterval()const
+{
+	return interval_;
+}
+
+void DescribeLiveDomainTimeShiftDataRequest::setInterval(const std::string& interval)
+{
+	interval_ = interval;
+	setParameter("Interval", interval);
+}
+

live/src/model/DescribeLiveDomainTimeShiftDataResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/live/model/DescribeLiveDomainTimeShiftDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLiveDomainTimeShiftDataResult::DescribeLiveDomainTimeShiftDataResult() :
+	ServiceResult()
+{}
+
+DescribeLiveDomainTimeShiftDataResult::DescribeLiveDomainTimeShiftDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLiveDomainTimeShiftDataResult::~DescribeLiveDomainTimeShiftDataResult()
+{}
+
+void DescribeLiveDomainTimeShiftDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTimeShiftDataNode = value["TimeShiftData"]["DataModule"];
+	for (auto valueTimeShiftDataDataModule : allTimeShiftDataNode)
+	{
+		DataModule timeShiftDataObject;
+		if(!valueTimeShiftDataDataModule["TimeStamp"].isNull())
+			timeShiftDataObject.timeStamp = valueTimeShiftDataDataModule["TimeStamp"].asString();
+		if(!valueTimeShiftDataDataModule["Size"].isNull())
+			timeShiftDataObject.size = valueTimeShiftDataDataModule["Size"].asString();
+		if(!valueTimeShiftDataDataModule["Type"].isNull())
+			timeShiftDataObject.type = valueTimeShiftDataDataModule["Type"].asString();
+		timeShiftData_.push_back(timeShiftDataObject);
+	}
+
+}
+
+std::vector<DescribeLiveDomainTimeShiftDataResult::DataModule> DescribeLiveDomainTimeShiftDataResult::getTimeShiftData()const
+{
+	return timeShiftData_;
+}
+

live/src/model/DescribeLivePullStreamConfigRequest.cc

@@ -1,62 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/live/model/DescribeLivePullStreamConfigRequest.h>
-
-using AlibabaCloud::Live::Model::DescribeLivePullStreamConfigRequest;
-
-DescribeLivePullStreamConfigRequest::DescribeLivePullStreamConfigRequest() :
-	RpcServiceRequest("live", "2016-11-01", "DescribeLivePullStreamConfig")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeLivePullStreamConfigRequest::~DescribeLivePullStreamConfigRequest()
-{}
-
-std::string DescribeLivePullStreamConfigRequest::getDomainName()const
-{
-	return domainName_;
-}
-
-void DescribeLivePullStreamConfigRequest::setDomainName(const std::string& domainName)
-{
-	domainName_ = domainName;
-	setParameter("DomainName", domainName);
-}
-
-long DescribeLivePullStreamConfigRequest::getOwnerId()const
-{
-	return ownerId_;
-}
-
-void DescribeLivePullStreamConfigRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
-}
-
-std::string DescribeLivePullStreamConfigRequest::getSecurityToken()const
-{
-	return securityToken_;
-}
-
-void DescribeLivePullStreamConfigRequest::setSecurityToken(const std::string& securityToken)
-{
-	securityToken_ = securityToken;
-	setParameter("SecurityToken", securityToken);
-}
-

live/src/model/DescribeLivePullStreamConfigResult.cc

@@ -1,67 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/live/model/DescribeLivePullStreamConfigResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Live;
-using namespace AlibabaCloud::Live::Model;
-
-DescribeLivePullStreamConfigResult::DescribeLivePullStreamConfigResult() :
-	ServiceResult()
-{}
-
-DescribeLivePullStreamConfigResult::DescribeLivePullStreamConfigResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeLivePullStreamConfigResult::~DescribeLivePullStreamConfigResult()
-{}
-
-void DescribeLivePullStreamConfigResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allLiveAppRecordListNode = value["LiveAppRecordList"]["LiveAppRecord"];
-	for (auto valueLiveAppRecordListLiveAppRecord : allLiveAppRecordListNode)
-	{
-		LiveAppRecord liveAppRecordListObject;
-		if(!valueLiveAppRecordListLiveAppRecord["DomainName"].isNull())
-			liveAppRecordListObject.domainName = valueLiveAppRecordListLiveAppRecord["DomainName"].asString();
-		if(!valueLiveAppRecordListLiveAppRecord["AppName"].isNull())
-			liveAppRecordListObject.appName = valueLiveAppRecordListLiveAppRecord["AppName"].asString();
-		if(!valueLiveAppRecordListLiveAppRecord["StreamName"].isNull())
-			liveAppRecordListObject.streamName = valueLiveAppRecordListLiveAppRecord["StreamName"].asString();
-		if(!valueLiveAppRecordListLiveAppRecord["SourceUrl"].isNull())
-			liveAppRecordListObject.sourceUrl = valueLiveAppRecordListLiveAppRecord["SourceUrl"].asString();
-		if(!valueLiveAppRecordListLiveAppRecord["StartTime"].isNull())
-			liveAppRecordListObject.startTime = valueLiveAppRecordListLiveAppRecord["StartTime"].asString();
-		if(!valueLiveAppRecordListLiveAppRecord["EndTime"].isNull())
-			liveAppRecordListObject.endTime = valueLiveAppRecordListLiveAppRecord["EndTime"].asString();
-		liveAppRecordList_.push_back(liveAppRecordListObject);
-	}
-
-}
-
-std::vector<DescribeLivePullStreamConfigResult::LiveAppRecord> DescribeLivePullStreamConfigResult::getLiveAppRecordList()const
-{
-	return liveAppRecordList_;
-}
-

live/src/model/DescribeLiveSnapshotConfigResult.cc

@@ -59,6 +59,8 @@ void DescribeLiveSnapshotConfigResult::parse(const std::string &payload)
 			liveStreamSnapshotConfigListObject.sequenceOssObject = valueLiveStreamSnapshotConfigListLiveStreamSnapshotConfig["SequenceOssObject"].asString();
 		if(!valueLiveStreamSnapshotConfigListLiveStreamSnapshotConfig["CreateTime"].isNull())
 			liveStreamSnapshotConfigListObject.createTime = valueLiveStreamSnapshotConfigListLiveStreamSnapshotConfig["CreateTime"].asString();
+		if(!valueLiveStreamSnapshotConfigListLiveStreamSnapshotConfig["Callback"].isNull())
+			liveStreamSnapshotConfigListObject.callback = valueLiveStreamSnapshotConfigListLiveStreamSnapshotConfig["Callback"].asString();
 		liveStreamSnapshotConfigList_.push_back(liveStreamSnapshotConfigListObject);
 	}
 	if(!value["PageNum"].isNull())

live/src/model/DescribeLiveStreamTranscodeInfoResult.cc

@@ -50,6 +50,10 @@ void DescribeLiveStreamTranscodeInfoResult::parse(const std::string &payload)
 		if(!valueDomainTranscodeListDomainTranscodeInfo["TranscodeTemplate"].isNull())
 			domainTranscodeListObject.transcodeTemplate = valueDomainTranscodeListDomainTranscodeInfo["TranscodeTemplate"].asString();
 		auto customTranscodeParametersNode = value["CustomTranscodeParameters"];
+		if(!customTranscodeParametersNode["RtsFlag"].isNull())
+			domainTranscodeListObject.customTranscodeParameters.rtsFlag = customTranscodeParametersNode["RtsFlag"].asString();
+		if(!customTranscodeParametersNode["Bframes"].isNull())
+			domainTranscodeListObject.customTranscodeParameters.bframes = customTranscodeParametersNode["Bframes"].asString();
 		if(!customTranscodeParametersNode["VideoBitrate"].isNull())
 			domainTranscodeListObject.customTranscodeParameters.videoBitrate = std::stoi(customTranscodeParametersNode["VideoBitrate"].asString());
 		if(!customTranscodeParametersNode["FPS"].isNull())

live/src/model/UnTagLiveResourcesRequest.cc

@@ -27,6 +27,17 @@ UnTagLiveResourcesRequest::UnTagLiveResourcesRequest() :
 UnTagLiveResourcesRequest::~UnTagLiveResourcesRequest()
 {}
 
+bool UnTagLiveResourcesRequest::getAll()const
+{
+	return all_;
+}
+
+void UnTagLiveResourcesRequest::setAll(bool all)
+{
+	all_ = all;
+	setParameter("All", all ? "true" : "false");
+}
+
 std::vector<std::string> UnTagLiveResourcesRequest::getResourceId()const
 {
 	return resourceId_;

live/src/model/UpdateLiveAppSnapshotConfigRequest.cc

@@ -126,3 +126,14 @@ void UpdateLiveAppSnapshotConfigRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
+std::string UpdateLiveAppSnapshotConfigRequest::getCallback()const
+{
+	return callback_;
+}
+
+void UpdateLiveAppSnapshotConfigRequest::setCallback(const std::string& callback)
+{
+	callback_ = callback;
+	setParameter("Callback", callback);
+}
+

onsmqtt/CMakeLists.txt

@@ -23,31 +23,43 @@ set(onsmqtt_public_header
 set(onsmqtt_public_header_model 
 	include/alibabacloud/onsmqtt/model/ApplyTokenRequest.h
 	include/alibabacloud/onsmqtt/model/ApplyTokenResult.h
+	include/alibabacloud/onsmqtt/model/BatchQuerySessionByClientIdsRequest.h
+	include/alibabacloud/onsmqtt/model/BatchQuerySessionByClientIdsResult.h
 	include/alibabacloud/onsmqtt/model/CreateGroupIdRequest.h
 	include/alibabacloud/onsmqtt/model/CreateGroupIdResult.h
 	include/alibabacloud/onsmqtt/model/DeleteGroupIdRequest.h
 	include/alibabacloud/onsmqtt/model/DeleteGroupIdResult.h
 	include/alibabacloud/onsmqtt/model/ListGroupIdRequest.h
 	include/alibabacloud/onsmqtt/model/ListGroupIdResult.h
+	include/alibabacloud/onsmqtt/model/QuerySessionByClientIdRequest.h
+	include/alibabacloud/onsmqtt/model/QuerySessionByClientIdResult.h
 	include/alibabacloud/onsmqtt/model/QueryTokenRequest.h
 	include/alibabacloud/onsmqtt/model/QueryTokenResult.h
 	include/alibabacloud/onsmqtt/model/RevokeTokenRequest.h
-	include/alibabacloud/onsmqtt/model/RevokeTokenResult.h )
+	include/alibabacloud/onsmqtt/model/RevokeTokenResult.h
+	include/alibabacloud/onsmqtt/model/SendMessageRequest.h
+	include/alibabacloud/onsmqtt/model/SendMessageResult.h )
 
 set(onsmqtt_src 
 	src/OnsMqttClient.cc
 	src/model/ApplyTokenRequest.cc
 	src/model/ApplyTokenResult.cc
+	src/model/BatchQuerySessionByClientIdsRequest.cc
+	src/model/BatchQuerySessionByClientIdsResult.cc
 	src/model/CreateGroupIdRequest.cc
 	src/model/CreateGroupIdResult.cc
 	src/model/DeleteGroupIdRequest.cc
 	src/model/DeleteGroupIdResult.cc
 	src/model/ListGroupIdRequest.cc
 	src/model/ListGroupIdResult.cc
+	src/model/QuerySessionByClientIdRequest.cc
+	src/model/QuerySessionByClientIdResult.cc
 	src/model/QueryTokenRequest.cc
 	src/model/QueryTokenResult.cc
 	src/model/RevokeTokenRequest.cc
-	src/model/RevokeTokenResult.cc )
+	src/model/RevokeTokenResult.cc
+	src/model/SendMessageRequest.cc
+	src/model/SendMessageResult.cc )
 
 add_library(onsmqtt ${LIB_TYPE}
 	${onsmqtt_public_header}

onsmqtt/include/alibabacloud/onsmqtt/OnsMqttClient.h

@@ -24,16 +24,22 @@
 #include "OnsMqttExport.h"
 #include "model/ApplyTokenRequest.h"
 #include "model/ApplyTokenResult.h"
+#include "model/BatchQuerySessionByClientIdsRequest.h"
+#include "model/BatchQuerySessionByClientIdsResult.h"
 #include "model/CreateGroupIdRequest.h"
 #include "model/CreateGroupIdResult.h"
 #include "model/DeleteGroupIdRequest.h"
 #include "model/DeleteGroupIdResult.h"
 #include "model/ListGroupIdRequest.h"
 #include "model/ListGroupIdResult.h"
+#include "model/QuerySessionByClientIdRequest.h"
+#include "model/QuerySessionByClientIdResult.h"
 #include "model/QueryTokenRequest.h"
 #include "model/QueryTokenResult.h"
 #include "model/RevokeTokenRequest.h"
 #include "model/RevokeTokenResult.h"
+#include "model/SendMessageRequest.h"
+#include "model/SendMessageResult.h"
 
 
 namespace AlibabaCloud
@@ -46,6 +52,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ApplyTokenResult> ApplyTokenOutcome;
 			typedef std::future<ApplyTokenOutcome> ApplyTokenOutcomeCallable;
 			typedef std::function<void(const OnsMqttClient*, const Model::ApplyTokenRequest&, const ApplyTokenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ApplyTokenAsyncHandler;
+			typedef Outcome<Error, Model::BatchQuerySessionByClientIdsResult> BatchQuerySessionByClientIdsOutcome;
+			typedef std::future<BatchQuerySessionByClientIdsOutcome> BatchQuerySessionByClientIdsOutcomeCallable;
+			typedef std::function<void(const OnsMqttClient*, const Model::BatchQuerySessionByClientIdsRequest&, const BatchQuerySessionByClientIdsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchQuerySessionByClientIdsAsyncHandler;
 			typedef Outcome<Error, Model::CreateGroupIdResult> CreateGroupIdOutcome;
 			typedef std::future<CreateGroupIdOutcome> CreateGroupIdOutcomeCallable;
 			typedef std::function<void(const OnsMqttClient*, const Model::CreateGroupIdRequest&, const CreateGroupIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGroupIdAsyncHandler;
@@ -55,12 +64,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListGroupIdResult> ListGroupIdOutcome;
 			typedef std::future<ListGroupIdOutcome> ListGroupIdOutcomeCallable;
 			typedef std::function<void(const OnsMqttClient*, const Model::ListGroupIdRequest&, const ListGroupIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListGroupIdAsyncHandler;
+			typedef Outcome<Error, Model::QuerySessionByClientIdResult> QuerySessionByClientIdOutcome;
+			typedef std::future<QuerySessionByClientIdOutcome> QuerySessionByClientIdOutcomeCallable;
+			typedef std::function<void(const OnsMqttClient*, const Model::QuerySessionByClientIdRequest&, const QuerySessionByClientIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QuerySessionByClientIdAsyncHandler;
 			typedef Outcome<Error, Model::QueryTokenResult> QueryTokenOutcome;
 			typedef std::future<QueryTokenOutcome> QueryTokenOutcomeCallable;
 			typedef std::function<void(const OnsMqttClient*, const Model::QueryTokenRequest&, const QueryTokenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryTokenAsyncHandler;
 			typedef Outcome<Error, Model::RevokeTokenResult> RevokeTokenOutcome;
 			typedef std::future<RevokeTokenOutcome> RevokeTokenOutcomeCallable;
 			typedef std::function<void(const OnsMqttClient*, const Model::RevokeTokenRequest&, const RevokeTokenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RevokeTokenAsyncHandler;
+			typedef Outcome<Error, Model::SendMessageResult> SendMessageOutcome;
+			typedef std::future<SendMessageOutcome> SendMessageOutcomeCallable;
+			typedef std::function<void(const OnsMqttClient*, const Model::SendMessageRequest&, const SendMessageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SendMessageAsyncHandler;
 
 			OnsMqttClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			OnsMqttClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
@@ -69,6 +84,9 @@ namespace AlibabaCloud
 			ApplyTokenOutcome applyToken(const Model::ApplyTokenRequest &request)const;
 			void applyTokenAsync(const Model::ApplyTokenRequest& request, const ApplyTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ApplyTokenOutcomeCallable applyTokenCallable(const Model::ApplyTokenRequest& request) const;
+			BatchQuerySessionByClientIdsOutcome batchQuerySessionByClientIds(const Model::BatchQuerySessionByClientIdsRequest &request)const;
+			void batchQuerySessionByClientIdsAsync(const Model::BatchQuerySessionByClientIdsRequest& request, const BatchQuerySessionByClientIdsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			BatchQuerySessionByClientIdsOutcomeCallable batchQuerySessionByClientIdsCallable(const Model::BatchQuerySessionByClientIdsRequest& request) const;
 			CreateGroupIdOutcome createGroupId(const Model::CreateGroupIdRequest &request)const;
 			void createGroupIdAsync(const Model::CreateGroupIdRequest& request, const CreateGroupIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateGroupIdOutcomeCallable createGroupIdCallable(const Model::CreateGroupIdRequest& request) const;
@@ -78,12 +96,18 @@ namespace AlibabaCloud
 			ListGroupIdOutcome listGroupId(const Model::ListGroupIdRequest &request)const;
 			void listGroupIdAsync(const Model::ListGroupIdRequest& request, const ListGroupIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListGroupIdOutcomeCallable listGroupIdCallable(const Model::ListGroupIdRequest& request) const;
+			QuerySessionByClientIdOutcome querySessionByClientId(const Model::QuerySessionByClientIdRequest &request)const;
+			void querySessionByClientIdAsync(const Model::QuerySessionByClientIdRequest& request, const QuerySessionByClientIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QuerySessionByClientIdOutcomeCallable querySessionByClientIdCallable(const Model::QuerySessionByClientIdRequest& request) const;
 			QueryTokenOutcome queryToken(const Model::QueryTokenRequest &request)const;
 			void queryTokenAsync(const Model::QueryTokenRequest& request, const QueryTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryTokenOutcomeCallable queryTokenCallable(const Model::QueryTokenRequest& request) const;
 			RevokeTokenOutcome revokeToken(const Model::RevokeTokenRequest &request)const;
 			void revokeTokenAsync(const Model::RevokeTokenRequest& request, const RevokeTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RevokeTokenOutcomeCallable revokeTokenCallable(const Model::RevokeTokenRequest& request) const;
+			SendMessageOutcome sendMessage(const Model::SendMessageRequest &request)const;
+			void sendMessageAsync(const Model::SendMessageRequest& request, const SendMessageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SendMessageOutcomeCallable sendMessageCallable(const Model::SendMessageRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

onsmqtt/include/alibabacloud/onsmqtt/model/BatchQuerySessionByClientIdsRequest.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_ONSMQTT_MODEL_BATCHQUERYSESSIONBYCLIENTIDSREQUEST_H_
+#define ALIBABACLOUD_ONSMQTT_MODEL_BATCHQUERYSESSIONBYCLIENTIDSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/onsmqtt/OnsMqttExport.h>
+
+namespace AlibabaCloud
+{
+	namespace OnsMqtt
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ONSMQTT_EXPORT BatchQuerySessionByClientIdsRequest : public RpcServiceRequest
+			{
+
+			public:
+				BatchQuerySessionByClientIdsRequest();
+				~BatchQuerySessionByClientIdsRequest();
+
+				std::vector<std::string> getClientIdList()const;
+				void setClientIdList(const std::vector<std::string>& clientIdList);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+
+            private:
+				std::vector<std::string> clientIdList_;
+				std::string instanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ONSMQTT_MODEL_BATCHQUERYSESSIONBYCLIENTIDSREQUEST_H_

onsmqtt/include/alibabacloud/onsmqtt/model/BatchQuerySessionByClientIdsResult.h

@@ -0,0 +1,56 @@
+/*
+ * 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_ONSMQTT_MODEL_BATCHQUERYSESSIONBYCLIENTIDSRESULT_H_
+#define ALIBABACLOUD_ONSMQTT_MODEL_BATCHQUERYSESSIONBYCLIENTIDSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/onsmqtt/OnsMqttExport.h>
+
+namespace AlibabaCloud
+{
+	namespace OnsMqtt
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ONSMQTT_EXPORT BatchQuerySessionByClientIdsResult : public ServiceResult
+			{
+			public:
+				struct OnlineStatusListItem
+				{
+					bool onlineStatus;
+					std::string clientId;
+				};
+
+
+				BatchQuerySessionByClientIdsResult();
+				explicit BatchQuerySessionByClientIdsResult(const std::string &payload);
+				~BatchQuerySessionByClientIdsResult();
+				std::vector<OnlineStatusListItem> getOnlineStatusList()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<OnlineStatusListItem> onlineStatusList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ONSMQTT_MODEL_BATCHQUERYSESSIONBYCLIENTIDSRESULT_H_

onsmqtt/include/alibabacloud/onsmqtt/model/QuerySessionByClientIdRequest.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_ONSMQTT_MODEL_QUERYSESSIONBYCLIENTIDREQUEST_H_
+#define ALIBABACLOUD_ONSMQTT_MODEL_QUERYSESSIONBYCLIENTIDREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/onsmqtt/OnsMqttExport.h>
+
+namespace AlibabaCloud
+{
+	namespace OnsMqtt
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ONSMQTT_EXPORT QuerySessionByClientIdRequest : public RpcServiceRequest
+			{
+
+			public:
+				QuerySessionByClientIdRequest();
+				~QuerySessionByClientIdRequest();
+
+				std::string getClientId()const;
+				void setClientId(const std::string& clientId);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+
+            private:
+				std::string clientId_;
+				std::string instanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ONSMQTT_MODEL_QUERYSESSIONBYCLIENTIDREQUEST_H_

onsmqtt/include/alibabacloud/onsmqtt/model/QuerySessionByClientIdResult.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_ONSMQTT_MODEL_QUERYSESSIONBYCLIENTIDRESULT_H_
+#define ALIBABACLOUD_ONSMQTT_MODEL_QUERYSESSIONBYCLIENTIDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/onsmqtt/OnsMqttExport.h>
+
+namespace AlibabaCloud
+{
+	namespace OnsMqtt
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ONSMQTT_EXPORT QuerySessionByClientIdResult : public ServiceResult
+			{
+			public:
+
+
+				QuerySessionByClientIdResult();
+				explicit QuerySessionByClientIdResult(const std::string &payload);
+				~QuerySessionByClientIdResult();
+				bool getOnlineStatus()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool onlineStatus_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ONSMQTT_MODEL_QUERYSESSIONBYCLIENTIDRESULT_H_

onsmqtt/include/alibabacloud/onsmqtt/model/SendMessageRequest.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_ONSMQTT_MODEL_SENDMESSAGEREQUEST_H_
+#define ALIBABACLOUD_ONSMQTT_MODEL_SENDMESSAGEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/onsmqtt/OnsMqttExport.h>
+
+namespace AlibabaCloud
+{
+	namespace OnsMqtt
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ONSMQTT_EXPORT SendMessageRequest : public RpcServiceRequest
+			{
+
+			public:
+				SendMessageRequest();
+				~SendMessageRequest();
+
+				std::string getMqttTopic()const;
+				void setMqttTopic(const std::string& mqttTopic);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+				std::string getPayload()const;
+				void setPayload(const std::string& payload);
+
+            private:
+				std::string mqttTopic_;
+				std::string instanceId_;
+				std::string payload_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ONSMQTT_MODEL_SENDMESSAGEREQUEST_H_

onsmqtt/include/alibabacloud/onsmqtt/model/SendMessageResult.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_ONSMQTT_MODEL_SENDMESSAGERESULT_H_
+#define ALIBABACLOUD_ONSMQTT_MODEL_SENDMESSAGERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/onsmqtt/OnsMqttExport.h>
+
+namespace AlibabaCloud
+{
+	namespace OnsMqtt
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ONSMQTT_EXPORT SendMessageResult : public ServiceResult
+			{
+			public:
+
+
+				SendMessageResult();
+				explicit SendMessageResult(const std::string &payload);
+				~SendMessageResult();
+				std::string getMsgId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string msgId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ONSMQTT_MODEL_SENDMESSAGERESULT_H_

onsmqtt/src/OnsMqttClient.cc

@@ -87,6 +87,42 @@ OnsMqttClient::ApplyTokenOutcomeCallable OnsMqttClient::applyTokenCallable(const
 	return task->get_future();
 }
 
+OnsMqttClient::BatchQuerySessionByClientIdsOutcome OnsMqttClient::batchQuerySessionByClientIds(const BatchQuerySessionByClientIdsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return BatchQuerySessionByClientIdsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return BatchQuerySessionByClientIdsOutcome(BatchQuerySessionByClientIdsResult(outcome.result()));
+	else
+		return BatchQuerySessionByClientIdsOutcome(outcome.error());
+}
+
+void OnsMqttClient::batchQuerySessionByClientIdsAsync(const BatchQuerySessionByClientIdsRequest& request, const BatchQuerySessionByClientIdsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, batchQuerySessionByClientIds(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+OnsMqttClient::BatchQuerySessionByClientIdsOutcomeCallable OnsMqttClient::batchQuerySessionByClientIdsCallable(const BatchQuerySessionByClientIdsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<BatchQuerySessionByClientIdsOutcome()>>(
+			[this, request]()
+			{
+			return this->batchQuerySessionByClientIds(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 OnsMqttClient::CreateGroupIdOutcome OnsMqttClient::createGroupId(const CreateGroupIdRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -195,6 +231,42 @@ OnsMqttClient::ListGroupIdOutcomeCallable OnsMqttClient::listGroupIdCallable(con
 	return task->get_future();
 }
 
+OnsMqttClient::QuerySessionByClientIdOutcome OnsMqttClient::querySessionByClientId(const QuerySessionByClientIdRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QuerySessionByClientIdOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QuerySessionByClientIdOutcome(QuerySessionByClientIdResult(outcome.result()));
+	else
+		return QuerySessionByClientIdOutcome(outcome.error());
+}
+
+void OnsMqttClient::querySessionByClientIdAsync(const QuerySessionByClientIdRequest& request, const QuerySessionByClientIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, querySessionByClientId(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+OnsMqttClient::QuerySessionByClientIdOutcomeCallable OnsMqttClient::querySessionByClientIdCallable(const QuerySessionByClientIdRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QuerySessionByClientIdOutcome()>>(
+			[this, request]()
+			{
+			return this->querySessionByClientId(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 OnsMqttClient::QueryTokenOutcome OnsMqttClient::queryToken(const QueryTokenRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -267,3 +339,39 @@ OnsMqttClient::RevokeTokenOutcomeCallable OnsMqttClient::revokeTokenCallable(con
 	return task->get_future();
 }
 
+OnsMqttClient::SendMessageOutcome OnsMqttClient::sendMessage(const SendMessageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SendMessageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SendMessageOutcome(SendMessageResult(outcome.result()));
+	else
+		return SendMessageOutcome(outcome.error());
+}
+
+void OnsMqttClient::sendMessageAsync(const SendMessageRequest& request, const SendMessageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, sendMessage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+OnsMqttClient::SendMessageOutcomeCallable OnsMqttClient::sendMessageCallable(const SendMessageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SendMessageOutcome()>>(
+			[this, request]()
+			{
+			return this->sendMessage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

onsmqtt/src/model/BatchQuerySessionByClientIdsRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/onsmqtt/model/BatchQuerySessionByClientIdsRequest.h>
+
+using AlibabaCloud::OnsMqtt::Model::BatchQuerySessionByClientIdsRequest;
+
+BatchQuerySessionByClientIdsRequest::BatchQuerySessionByClientIdsRequest() :
+	RpcServiceRequest("onsmqtt", "2020-04-20", "BatchQuerySessionByClientIds")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+BatchQuerySessionByClientIdsRequest::~BatchQuerySessionByClientIdsRequest()
+{}
+
+std::vector<std::string> BatchQuerySessionByClientIdsRequest::getClientIdList()const
+{
+	return clientIdList_;
+}
+
+void BatchQuerySessionByClientIdsRequest::setClientIdList(const std::vector<std::string>& clientIdList)
+{
+	clientIdList_ = clientIdList;
+	for(int dep1 = 0; dep1!= clientIdList.size(); dep1++) {
+		setParameter("ClientIdList."+ std::to_string(dep1), clientIdList.at(dep1));
+	}
+}
+
+std::string BatchQuerySessionByClientIdsRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void BatchQuerySessionByClientIdsRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+

onsmqtt/src/model/BatchQuerySessionByClientIdsResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/onsmqtt/model/BatchQuerySessionByClientIdsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::OnsMqtt;
+using namespace AlibabaCloud::OnsMqtt::Model;
+
+BatchQuerySessionByClientIdsResult::BatchQuerySessionByClientIdsResult() :
+	ServiceResult()
+{}
+
+BatchQuerySessionByClientIdsResult::BatchQuerySessionByClientIdsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+BatchQuerySessionByClientIdsResult::~BatchQuerySessionByClientIdsResult()
+{}
+
+void BatchQuerySessionByClientIdsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allOnlineStatusListNode = value["OnlineStatusList"]["OnlineStatusListItem"];
+	for (auto valueOnlineStatusListOnlineStatusListItem : allOnlineStatusListNode)
+	{
+		OnlineStatusListItem onlineStatusListObject;
+		if(!valueOnlineStatusListOnlineStatusListItem["ClientId"].isNull())
+			onlineStatusListObject.clientId = valueOnlineStatusListOnlineStatusListItem["ClientId"].asString();
+		if(!valueOnlineStatusListOnlineStatusListItem["OnlineStatus"].isNull())
+			onlineStatusListObject.onlineStatus = valueOnlineStatusListOnlineStatusListItem["OnlineStatus"].asString() == "true";
+		onlineStatusList_.push_back(onlineStatusListObject);
+	}
+
+}
+
+std::vector<BatchQuerySessionByClientIdsResult::OnlineStatusListItem> BatchQuerySessionByClientIdsResult::getOnlineStatusList()const
+{
+	return onlineStatusList_;
+}
+

onsmqtt/src/model/QuerySessionByClientIdRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/onsmqtt/model/QuerySessionByClientIdRequest.h>
+
+using AlibabaCloud::OnsMqtt::Model::QuerySessionByClientIdRequest;
+
+QuerySessionByClientIdRequest::QuerySessionByClientIdRequest() :
+	RpcServiceRequest("onsmqtt", "2020-04-20", "QuerySessionByClientId")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+QuerySessionByClientIdRequest::~QuerySessionByClientIdRequest()
+{}
+
+std::string QuerySessionByClientIdRequest::getClientId()const
+{
+	return clientId_;
+}
+
+void QuerySessionByClientIdRequest::setClientId(const std::string& clientId)
+{
+	clientId_ = clientId;
+	setParameter("ClientId", clientId);
+}
+
+std::string QuerySessionByClientIdRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void QuerySessionByClientIdRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+

onsmqtt/src/model/QuerySessionByClientIdResult.cc

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

onsmqtt/src/model/SendMessageRequest.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/onsmqtt/model/SendMessageRequest.h>
+
+using AlibabaCloud::OnsMqtt::Model::SendMessageRequest;
+
+SendMessageRequest::SendMessageRequest() :
+	RpcServiceRequest("onsmqtt", "2020-04-20", "SendMessage")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+SendMessageRequest::~SendMessageRequest()
+{}
+
+std::string SendMessageRequest::getMqttTopic()const
+{
+	return mqttTopic_;
+}
+
+void SendMessageRequest::setMqttTopic(const std::string& mqttTopic)
+{
+	mqttTopic_ = mqttTopic;
+	setParameter("MqttTopic", mqttTopic);
+}
+
+std::string SendMessageRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void SendMessageRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string SendMessageRequest::getPayload()const
+{
+	return payload_;
+}
+
+void SendMessageRequest::setPayload(const std::string& payload)
+{
+	payload_ = payload;
+	setParameter("Payload", payload);
+}
+

onsmqtt/src/model/SendMessageResult.cc

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

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/AllocateDirectConnectionRequest.h
+	include/alibabacloud/r-kvstore/model/AllocateDirectConnectionResult.h
 	include/alibabacloud/r-kvstore/model/AllocateInstancePublicConnectionRequest.h
 	include/alibabacloud/r-kvstore/model/AllocateInstancePublicConnectionResult.h
 	include/alibabacloud/r-kvstore/model/CreateAccountRequest.h
@@ -33,6 +35,8 @@ set(r-kvstore_public_header_model
 	include/alibabacloud/r-kvstore/model/CreateDedicatedInstanceResult.h
 	include/alibabacloud/r-kvstore/model/CreateDedicatedUserClusterRequest.h
 	include/alibabacloud/r-kvstore/model/CreateDedicatedUserClusterResult.h
+	include/alibabacloud/r-kvstore/model/CreateGlobalDistributeCacheRequest.h
+	include/alibabacloud/r-kvstore/model/CreateGlobalDistributeCacheResult.h
 	include/alibabacloud/r-kvstore/model/CreateInstanceRequest.h
 	include/alibabacloud/r-kvstore/model/CreateInstanceResult.h
 	include/alibabacloud/r-kvstore/model/CreateUserClusterHostRequest.h
@@ -67,6 +71,8 @@ set(r-kvstore_public_header_model
 	include/alibabacloud/r-kvstore/model/DescribeDedicatedClusterInstanceListResult.h
 	include/alibabacloud/r-kvstore/model/DescribeDedicatedUserClusterRequest.h
 	include/alibabacloud/r-kvstore/model/DescribeDedicatedUserClusterResult.h
+	include/alibabacloud/r-kvstore/model/DescribeGlobalDistributeCacheRequest.h
+	include/alibabacloud/r-kvstore/model/DescribeGlobalDistributeCacheResult.h
 	include/alibabacloud/r-kvstore/model/DescribeHistoryMonitorValuesRequest.h
 	include/alibabacloud/r-kvstore/model/DescribeHistoryMonitorValuesResult.h
 	include/alibabacloud/r-kvstore/model/DescribeInstanceAttributeRequest.h
@@ -155,6 +161,8 @@ set(r-kvstore_public_header_model
 	include/alibabacloud/r-kvstore/model/ModifySecurityIpsResult.h
 	include/alibabacloud/r-kvstore/model/ModifyUserClusterHostRequest.h
 	include/alibabacloud/r-kvstore/model/ModifyUserClusterHostResult.h
+	include/alibabacloud/r-kvstore/model/ReleaseDirectConnectionRequest.h
+	include/alibabacloud/r-kvstore/model/ReleaseDirectConnectionResult.h
 	include/alibabacloud/r-kvstore/model/ReleaseInstancePublicConnectionRequest.h
 	include/alibabacloud/r-kvstore/model/ReleaseInstancePublicConnectionResult.h
 	include/alibabacloud/r-kvstore/model/RenewInstanceRequest.h
@@ -180,6 +188,8 @@ set(r-kvstore_public_header_model
 
 set(r-kvstore_src 
 	src/R-kvstoreClient.cc
+	src/model/AllocateDirectConnectionRequest.cc
+	src/model/AllocateDirectConnectionResult.cc
 	src/model/AllocateInstancePublicConnectionRequest.cc
 	src/model/AllocateInstancePublicConnectionResult.cc
 	src/model/CreateAccountRequest.cc
@@ -192,6 +202,8 @@ set(r-kvstore_src
 	src/model/CreateDedicatedInstanceResult.cc
 	src/model/CreateDedicatedUserClusterRequest.cc
 	src/model/CreateDedicatedUserClusterResult.cc
+	src/model/CreateGlobalDistributeCacheRequest.cc
+	src/model/CreateGlobalDistributeCacheResult.cc
 	src/model/CreateInstanceRequest.cc
 	src/model/CreateInstanceResult.cc
 	src/model/CreateUserClusterHostRequest.cc
@@ -226,6 +238,8 @@ set(r-kvstore_src
 	src/model/DescribeDedicatedClusterInstanceListResult.cc
 	src/model/DescribeDedicatedUserClusterRequest.cc
 	src/model/DescribeDedicatedUserClusterResult.cc
+	src/model/DescribeGlobalDistributeCacheRequest.cc
+	src/model/DescribeGlobalDistributeCacheResult.cc
 	src/model/DescribeHistoryMonitorValuesRequest.cc
 	src/model/DescribeHistoryMonitorValuesResult.cc
 	src/model/DescribeInstanceAttributeRequest.cc
@@ -314,6 +328,8 @@ set(r-kvstore_src
 	src/model/ModifySecurityIpsResult.cc
 	src/model/ModifyUserClusterHostRequest.cc
 	src/model/ModifyUserClusterHostResult.cc
+	src/model/ReleaseDirectConnectionRequest.cc
+	src/model/ReleaseDirectConnectionResult.cc
 	src/model/ReleaseInstancePublicConnectionRequest.cc
 	src/model/ReleaseInstancePublicConnectionResult.cc
 	src/model/RenewInstanceRequest.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/AllocateDirectConnectionRequest.h"
+#include "model/AllocateDirectConnectionResult.h"
 #include "model/AllocateInstancePublicConnectionRequest.h"
 #include "model/AllocateInstancePublicConnectionResult.h"
 #include "model/CreateAccountRequest.h"
@@ -34,6 +36,8 @@
 #include "model/CreateDedicatedInstanceResult.h"
 #include "model/CreateDedicatedUserClusterRequest.h"
 #include "model/CreateDedicatedUserClusterResult.h"
+#include "model/CreateGlobalDistributeCacheRequest.h"
+#include "model/CreateGlobalDistributeCacheResult.h"
 #include "model/CreateInstanceRequest.h"
 #include "model/CreateInstanceResult.h"
 #include "model/CreateUserClusterHostRequest.h"
@@ -68,6 +72,8 @@
 #include "model/DescribeDedicatedClusterInstanceListResult.h"
 #include "model/DescribeDedicatedUserClusterRequest.h"
 #include "model/DescribeDedicatedUserClusterResult.h"
+#include "model/DescribeGlobalDistributeCacheRequest.h"
+#include "model/DescribeGlobalDistributeCacheResult.h"
 #include "model/DescribeHistoryMonitorValuesRequest.h"
 #include "model/DescribeHistoryMonitorValuesResult.h"
 #include "model/DescribeInstanceAttributeRequest.h"
@@ -156,6 +162,8 @@
 #include "model/ModifySecurityIpsResult.h"
 #include "model/ModifyUserClusterHostRequest.h"
 #include "model/ModifyUserClusterHostResult.h"
+#include "model/ReleaseDirectConnectionRequest.h"
+#include "model/ReleaseDirectConnectionResult.h"
 #include "model/ReleaseInstancePublicConnectionRequest.h"
 #include "model/ReleaseInstancePublicConnectionResult.h"
 #include "model/RenewInstanceRequest.h"
@@ -187,6 +195,9 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_R_KVSTORE_EXPORT R_kvstoreClient : public RpcServiceClient
 		{
 		public:
+			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;
 			typedef Outcome<Error, Model::AllocateInstancePublicConnectionResult> AllocateInstancePublicConnectionOutcome;
 			typedef std::future<AllocateInstancePublicConnectionOutcome> AllocateInstancePublicConnectionOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::AllocateInstancePublicConnectionRequest&, const AllocateInstancePublicConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AllocateInstancePublicConnectionAsyncHandler;
@@ -205,6 +216,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateDedicatedUserClusterResult> CreateDedicatedUserClusterOutcome;
 			typedef std::future<CreateDedicatedUserClusterOutcome> CreateDedicatedUserClusterOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::CreateDedicatedUserClusterRequest&, const CreateDedicatedUserClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDedicatedUserClusterAsyncHandler;
+			typedef Outcome<Error, Model::CreateGlobalDistributeCacheResult> CreateGlobalDistributeCacheOutcome;
+			typedef std::future<CreateGlobalDistributeCacheOutcome> CreateGlobalDistributeCacheOutcomeCallable;
+			typedef std::function<void(const R_kvstoreClient*, const Model::CreateGlobalDistributeCacheRequest&, const CreateGlobalDistributeCacheOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGlobalDistributeCacheAsyncHandler;
 			typedef Outcome<Error, Model::CreateInstanceResult> CreateInstanceOutcome;
 			typedef std::future<CreateInstanceOutcome> CreateInstanceOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::CreateInstanceRequest&, const CreateInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateInstanceAsyncHandler;
@@ -256,6 +270,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeDedicatedUserClusterResult> DescribeDedicatedUserClusterOutcome;
 			typedef std::future<DescribeDedicatedUserClusterOutcome> DescribeDedicatedUserClusterOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::DescribeDedicatedUserClusterRequest&, const DescribeDedicatedUserClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDedicatedUserClusterAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGlobalDistributeCacheResult> DescribeGlobalDistributeCacheOutcome;
+			typedef std::future<DescribeGlobalDistributeCacheOutcome> DescribeGlobalDistributeCacheOutcomeCallable;
+			typedef std::function<void(const R_kvstoreClient*, const Model::DescribeGlobalDistributeCacheRequest&, const DescribeGlobalDistributeCacheOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGlobalDistributeCacheAsyncHandler;
 			typedef Outcome<Error, Model::DescribeHistoryMonitorValuesResult> DescribeHistoryMonitorValuesOutcome;
 			typedef std::future<DescribeHistoryMonitorValuesOutcome> DescribeHistoryMonitorValuesOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::DescribeHistoryMonitorValuesRequest&, const DescribeHistoryMonitorValuesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeHistoryMonitorValuesAsyncHandler;
@@ -388,6 +405,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ModifyUserClusterHostResult> ModifyUserClusterHostOutcome;
 			typedef std::future<ModifyUserClusterHostOutcome> ModifyUserClusterHostOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::ModifyUserClusterHostRequest&, const ModifyUserClusterHostOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyUserClusterHostAsyncHandler;
+			typedef Outcome<Error, Model::ReleaseDirectConnectionResult> ReleaseDirectConnectionOutcome;
+			typedef std::future<ReleaseDirectConnectionOutcome> ReleaseDirectConnectionOutcomeCallable;
+			typedef std::function<void(const R_kvstoreClient*, const Model::ReleaseDirectConnectionRequest&, const ReleaseDirectConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReleaseDirectConnectionAsyncHandler;
 			typedef Outcome<Error, Model::ReleaseInstancePublicConnectionResult> ReleaseInstancePublicConnectionOutcome;
 			typedef std::future<ReleaseInstancePublicConnectionOutcome> ReleaseInstancePublicConnectionOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::ReleaseInstancePublicConnectionRequest&, const ReleaseInstancePublicConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReleaseInstancePublicConnectionAsyncHandler;
@@ -426,6 +446,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();
+			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;
 			AllocateInstancePublicConnectionOutcome allocateInstancePublicConnection(const Model::AllocateInstancePublicConnectionRequest &request)const;
 			void allocateInstancePublicConnectionAsync(const Model::AllocateInstancePublicConnectionRequest& request, const AllocateInstancePublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AllocateInstancePublicConnectionOutcomeCallable allocateInstancePublicConnectionCallable(const Model::AllocateInstancePublicConnectionRequest& request) const;
@@ -444,6 +467,9 @@ namespace AlibabaCloud
 			CreateDedicatedUserClusterOutcome createDedicatedUserCluster(const Model::CreateDedicatedUserClusterRequest &request)const;
 			void createDedicatedUserClusterAsync(const Model::CreateDedicatedUserClusterRequest& request, const CreateDedicatedUserClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateDedicatedUserClusterOutcomeCallable createDedicatedUserClusterCallable(const Model::CreateDedicatedUserClusterRequest& request) const;
+			CreateGlobalDistributeCacheOutcome createGlobalDistributeCache(const Model::CreateGlobalDistributeCacheRequest &request)const;
+			void createGlobalDistributeCacheAsync(const Model::CreateGlobalDistributeCacheRequest& request, const CreateGlobalDistributeCacheAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateGlobalDistributeCacheOutcomeCallable createGlobalDistributeCacheCallable(const Model::CreateGlobalDistributeCacheRequest& request) const;
 			CreateInstanceOutcome createInstance(const Model::CreateInstanceRequest &request)const;
 			void createInstanceAsync(const Model::CreateInstanceRequest& request, const CreateInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateInstanceOutcomeCallable createInstanceCallable(const Model::CreateInstanceRequest& request) const;
@@ -495,6 +521,9 @@ namespace AlibabaCloud
 			DescribeDedicatedUserClusterOutcome describeDedicatedUserCluster(const Model::DescribeDedicatedUserClusterRequest &request)const;
 			void describeDedicatedUserClusterAsync(const Model::DescribeDedicatedUserClusterRequest& request, const DescribeDedicatedUserClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDedicatedUserClusterOutcomeCallable describeDedicatedUserClusterCallable(const Model::DescribeDedicatedUserClusterRequest& request) const;
+			DescribeGlobalDistributeCacheOutcome describeGlobalDistributeCache(const Model::DescribeGlobalDistributeCacheRequest &request)const;
+			void describeGlobalDistributeCacheAsync(const Model::DescribeGlobalDistributeCacheRequest& request, const DescribeGlobalDistributeCacheAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGlobalDistributeCacheOutcomeCallable describeGlobalDistributeCacheCallable(const Model::DescribeGlobalDistributeCacheRequest& request) const;
 			DescribeHistoryMonitorValuesOutcome describeHistoryMonitorValues(const Model::DescribeHistoryMonitorValuesRequest &request)const;
 			void describeHistoryMonitorValuesAsync(const Model::DescribeHistoryMonitorValuesRequest& request, const DescribeHistoryMonitorValuesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeHistoryMonitorValuesOutcomeCallable describeHistoryMonitorValuesCallable(const Model::DescribeHistoryMonitorValuesRequest& request) const;
@@ -627,6 +656,9 @@ namespace AlibabaCloud
 			ModifyUserClusterHostOutcome modifyUserClusterHost(const Model::ModifyUserClusterHostRequest &request)const;
 			void modifyUserClusterHostAsync(const Model::ModifyUserClusterHostRequest& request, const ModifyUserClusterHostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyUserClusterHostOutcomeCallable modifyUserClusterHostCallable(const Model::ModifyUserClusterHostRequest& request) const;
+			ReleaseDirectConnectionOutcome releaseDirectConnection(const Model::ReleaseDirectConnectionRequest &request)const;
+			void releaseDirectConnectionAsync(const Model::ReleaseDirectConnectionRequest& request, const ReleaseDirectConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ReleaseDirectConnectionOutcomeCallable releaseDirectConnectionCallable(const Model::ReleaseDirectConnectionRequest& request) const;
 			ReleaseInstancePublicConnectionOutcome releaseInstancePublicConnection(const Model::ReleaseInstancePublicConnectionRequest &request)const;
 			void releaseInstancePublicConnectionAsync(const Model::ReleaseInstancePublicConnectionRequest& request, const ReleaseInstancePublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ReleaseInstancePublicConnectionOutcomeCallable releaseInstancePublicConnectionCallable(const Model::ReleaseInstancePublicConnectionRequest& request) const;

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

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_R_KVSTORE_MODEL_ALLOCATEDIRECTCONNECTIONREQUEST_H_
+#define ALIBABACLOUD_R_KVSTORE_MODEL_ALLOCATEDIRECTCONNECTIONREQUEST_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 AllocateDirectConnectionRequest : public RpcServiceRequest
+			{
+
+			public:
+				AllocateDirectConnectionRequest();
+				~AllocateDirectConnectionRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getConnectionString()const;
+				void setConnectionString(const std::string& connectionString);
+				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);
+				std::string getPort()const;
+				void setPort(const std::string& port);
+
+            private:
+				long resourceOwnerId_;
+				std::string connectionString_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string instanceId_;
+				std::string port_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_R_KVSTORE_MODEL_ALLOCATEDIRECTCONNECTIONREQUEST_H_

r-kvstore/include/alibabacloud/r-kvstore/model/AllocateDirectConnectionResult.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_ALLOCATEDIRECTCONNECTIONRESULT_H_
+#define ALIBABACLOUD_R_KVSTORE_MODEL_ALLOCATEDIRECTCONNECTIONRESULT_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 AllocateDirectConnectionResult : public ServiceResult
+			{
+			public:
+
+
+				AllocateDirectConnectionResult();
+				explicit AllocateDirectConnectionResult(const std::string &payload);
+				~AllocateDirectConnectionResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_R_KVSTORE_MODEL_ALLOCATEDIRECTCONNECTIONRESULT_H_

r-kvstore/include/alibabacloud/r-kvstore/model/CreateGlobalDistributeCacheRequest.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_CREATEGLOBALDISTRIBUTECACHEREQUEST_H_
+#define ALIBABACLOUD_R_KVSTORE_MODEL_CREATEGLOBALDISTRIBUTECACHEREQUEST_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 CreateGlobalDistributeCacheRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateGlobalDistributeCacheRequest();
+				~CreateGlobalDistributeCacheRequest();
+
+				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 getSeedSubInstanceId()const;
+				void setSeedSubInstanceId(const std::string& seedSubInstanceId);
+
+            private:
+				long resourceOwnerId_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string seedSubInstanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_R_KVSTORE_MODEL_CREATEGLOBALDISTRIBUTECACHEREQUEST_H_

r-kvstore/include/alibabacloud/r-kvstore/model/CreateGlobalDistributeCacheResult.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_R_KVSTORE_MODEL_CREATEGLOBALDISTRIBUTECACHERESULT_H_
+#define ALIBABACLOUD_R_KVSTORE_MODEL_CREATEGLOBALDISTRIBUTECACHERESULT_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 CreateGlobalDistributeCacheResult : public ServiceResult
+			{
+			public:
+
+
+				CreateGlobalDistributeCacheResult();
+				explicit CreateGlobalDistributeCacheResult(const std::string &payload);
+				~CreateGlobalDistributeCacheResult();
+				std::string getGlobalInstanceId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string globalInstanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_R_KVSTORE_MODEL_CREATEGLOBALDISTRIBUTECACHERESULT_H_

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

@@ -51,6 +51,8 @@ namespace AlibabaCloud
 				void setSecurityToken(const std::string& securityToken);
 				std::string getBusinessInfo()const;
 				void setBusinessInfo(const std::string& businessInfo);
+				int getShardCount()const;
+				void setShardCount(int shardCount);
 				std::string getAutoRenewPeriod()const;
 				void setAutoRenewPeriod(const std::string& autoRenewPeriod);
 				std::string getPeriod()const;
@@ -91,8 +93,12 @@ namespace AlibabaCloud
 				void setSrcDBInstanceId(const std::string& srcDBInstanceId);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
+				bool getGlobalInstance()const;
+				void setGlobalInstance(bool globalInstance);
 				std::string getToken()const;
 				void setToken(const std::string& token);
+				std::string getGlobalInstanceId()const;
+				void setGlobalInstanceId(const std::string& globalInstanceId);
 				std::string getVpcId()const;
 				void setVpcId(const std::string& vpcId);
 				std::string getChargeType()const;
@@ -109,6 +115,7 @@ namespace AlibabaCloud
 				std::string password_;
 				std::string securityToken_;
 				std::string businessInfo_;
+				int shardCount_;
 				std::string autoRenewPeriod_;
 				std::string period_;
 				std::string backupId_;
@@ -129,7 +136,9 @@ namespace AlibabaCloud
 				std::string resourceOwnerAccount_;
 				std::string srcDBInstanceId_;
 				std::string ownerAccount_;
+				bool globalInstance_;
 				std::string token_;
+				std::string globalInstanceId_;
 				std::string vpcId_;
 				std::string chargeType_;
 				std::string config_;

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

@@ -37,27 +37,33 @@ namespace AlibabaCloud
 
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
+				bool getReleaseSubInstance()const;
+				void setReleaseSubInstance(bool releaseSubInstance);
+				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 getAccessKeyId()const;
-				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getGlobalInstanceId()const;
+				void setGlobalInstanceId(const std::string& globalInstanceId);
 				std::string getInstanceId()const;
 				void setInstanceId(const std::string& instanceId);
-				std::string getSecurityToken()const;
-				void setSecurityToken(const std::string& securityToken);
 
             private:
 				long resourceOwnerId_;
+				bool releaseSubInstance_;
+				std::string accessKeyId_;
+				std::string securityToken_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
 				long ownerId_;
-				std::string accessKeyId_;
+				std::string globalInstanceId_;
 				std::string instanceId_;
-				std::string securityToken_;
 
 			};
 		}

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

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_R_KVSTORE_MODEL_DESCRIBEGLOBALDISTRIBUTECACHEREQUEST_H_
+#define ALIBABACLOUD_R_KVSTORE_MODEL_DESCRIBEGLOBALDISTRIBUTECACHEREQUEST_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 DescribeGlobalDistributeCacheRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeGlobalDistributeCacheRequest();
+				~DescribeGlobalDistributeCacheRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getPageNumber()const;
+				void setPageNumber(const std::string& pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getPageSize()const;
+				void setPageSize(const std::string& pageSize);
+				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 getGlobalInstanceId()const;
+				void setGlobalInstanceId(const std::string& globalInstanceId);
+
+            private:
+				long resourceOwnerId_;
+				std::string pageNumber_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string pageSize_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string globalInstanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_R_KVSTORE_MODEL_DESCRIBEGLOBALDISTRIBUTECACHEREQUEST_H_

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

@@ -0,0 +1,71 @@
+/*
+ * 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_DESCRIBEGLOBALDISTRIBUTECACHERESULT_H_
+#define ALIBABACLOUD_R_KVSTORE_MODEL_DESCRIBEGLOBALDISTRIBUTECACHERESULT_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 DescribeGlobalDistributeCacheResult : public ServiceResult
+			{
+			public:
+				struct GlobalDistributeCache
+				{
+					struct SubInstance
+					{
+						std::string instanceID;
+						std::string instanceStatus;
+						std::string globalInstanceId;
+						std::string regionId;
+					};
+					std::string status;
+					std::vector<GlobalDistributeCache::SubInstance> subInstances;
+					std::string globalInstanceId;
+					std::string globalInstanceName;
+				};
+
+
+				DescribeGlobalDistributeCacheResult();
+				explicit DescribeGlobalDistributeCacheResult(const std::string &payload);
+				~DescribeGlobalDistributeCacheResult();
+				int getTotalRecordCount()const;
+				std::vector<GlobalDistributeCache> getGlobalDistributeCaches()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalRecordCount_;
+				std::vector<GlobalDistributeCache> globalDistributeCaches_;
+				int pageSize_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_R_KVSTORE_MODEL_DESCRIBEGLOBALDISTRIBUTECACHERESULT_H_

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

@@ -73,6 +73,8 @@ namespace AlibabaCloud
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
+				bool getGlobalInstance()const;
+				void setGlobalInstance(bool globalInstance);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
 				std::string getVSwitchId()const;
@@ -107,6 +109,7 @@ namespace AlibabaCloud
 				std::string instanceStatus_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
+				bool globalInstance_;
 				long ownerId_;
 				std::string vSwitchId_;
 				int vpcCloudInsInfo_;

r-kvstore/include/alibabacloud/r-kvstore/model/ReleaseDirectConnectionRequest.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_RELEASEDIRECTCONNECTIONREQUEST_H_
+#define ALIBABACLOUD_R_KVSTORE_MODEL_RELEASEDIRECTCONNECTIONREQUEST_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 ReleaseDirectConnectionRequest : public RpcServiceRequest
+			{
+
+			public:
+				ReleaseDirectConnectionRequest();
+				~ReleaseDirectConnectionRequest();
+
+				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_RELEASEDIRECTCONNECTIONREQUEST_H_

r-kvstore/include/alibabacloud/r-kvstore/model/ReleaseDirectConnectionResult.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_RELEASEDIRECTCONNECTIONRESULT_H_
+#define ALIBABACLOUD_R_KVSTORE_MODEL_RELEASEDIRECTCONNECTIONRESULT_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 ReleaseDirectConnectionResult : public ServiceResult
+			{
+			public:
+
+
+				ReleaseDirectConnectionResult();
+				explicit ReleaseDirectConnectionResult(const std::string &payload);
+				~ReleaseDirectConnectionResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_R_KVSTORE_MODEL_RELEASEDIRECTCONNECTIONRESULT_H_

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::AllocateDirectConnectionOutcome R_kvstoreClient::allocateDirectConnection(const AllocateDirectConnectionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AllocateDirectConnectionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AllocateDirectConnectionOutcome(AllocateDirectConnectionResult(outcome.result()));
+	else
+		return AllocateDirectConnectionOutcome(outcome.error());
+}
+
+void R_kvstoreClient::allocateDirectConnectionAsync(const AllocateDirectConnectionRequest& request, const AllocateDirectConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, allocateDirectConnection(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+R_kvstoreClient::AllocateDirectConnectionOutcomeCallable R_kvstoreClient::allocateDirectConnectionCallable(const AllocateDirectConnectionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AllocateDirectConnectionOutcome()>>(
+			[this, request]()
+			{
+			return this->allocateDirectConnection(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 R_kvstoreClient::AllocateInstancePublicConnectionOutcome R_kvstoreClient::allocateInstancePublicConnection(const AllocateInstancePublicConnectionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -267,6 +303,42 @@ R_kvstoreClient::CreateDedicatedUserClusterOutcomeCallable R_kvstoreClient::crea
 	return task->get_future();
 }
 
+R_kvstoreClient::CreateGlobalDistributeCacheOutcome R_kvstoreClient::createGlobalDistributeCache(const CreateGlobalDistributeCacheRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateGlobalDistributeCacheOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateGlobalDistributeCacheOutcome(CreateGlobalDistributeCacheResult(outcome.result()));
+	else
+		return CreateGlobalDistributeCacheOutcome(outcome.error());
+}
+
+void R_kvstoreClient::createGlobalDistributeCacheAsync(const CreateGlobalDistributeCacheRequest& request, const CreateGlobalDistributeCacheAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createGlobalDistributeCache(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+R_kvstoreClient::CreateGlobalDistributeCacheOutcomeCallable R_kvstoreClient::createGlobalDistributeCacheCallable(const CreateGlobalDistributeCacheRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateGlobalDistributeCacheOutcome()>>(
+			[this, request]()
+			{
+			return this->createGlobalDistributeCache(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 R_kvstoreClient::CreateInstanceOutcome R_kvstoreClient::createInstance(const CreateInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -879,6 +951,42 @@ R_kvstoreClient::DescribeDedicatedUserClusterOutcomeCallable R_kvstoreClient::de
 	return task->get_future();
 }
 
+R_kvstoreClient::DescribeGlobalDistributeCacheOutcome R_kvstoreClient::describeGlobalDistributeCache(const DescribeGlobalDistributeCacheRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeGlobalDistributeCacheOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeGlobalDistributeCacheOutcome(DescribeGlobalDistributeCacheResult(outcome.result()));
+	else
+		return DescribeGlobalDistributeCacheOutcome(outcome.error());
+}
+
+void R_kvstoreClient::describeGlobalDistributeCacheAsync(const DescribeGlobalDistributeCacheRequest& request, const DescribeGlobalDistributeCacheAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeGlobalDistributeCache(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+R_kvstoreClient::DescribeGlobalDistributeCacheOutcomeCallable R_kvstoreClient::describeGlobalDistributeCacheCallable(const DescribeGlobalDistributeCacheRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeGlobalDistributeCacheOutcome()>>(
+			[this, request]()
+			{
+			return this->describeGlobalDistributeCache(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 R_kvstoreClient::DescribeHistoryMonitorValuesOutcome R_kvstoreClient::describeHistoryMonitorValues(const DescribeHistoryMonitorValuesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2463,6 +2571,42 @@ R_kvstoreClient::ModifyUserClusterHostOutcomeCallable R_kvstoreClient::modifyUse
 	return task->get_future();
 }
 
+R_kvstoreClient::ReleaseDirectConnectionOutcome R_kvstoreClient::releaseDirectConnection(const ReleaseDirectConnectionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ReleaseDirectConnectionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ReleaseDirectConnectionOutcome(ReleaseDirectConnectionResult(outcome.result()));
+	else
+		return ReleaseDirectConnectionOutcome(outcome.error());
+}
+
+void R_kvstoreClient::releaseDirectConnectionAsync(const ReleaseDirectConnectionRequest& request, const ReleaseDirectConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, releaseDirectConnection(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+R_kvstoreClient::ReleaseDirectConnectionOutcomeCallable R_kvstoreClient::releaseDirectConnectionCallable(const ReleaseDirectConnectionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ReleaseDirectConnectionOutcome()>>(
+			[this, request]()
+			{
+			return this->releaseDirectConnection(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 R_kvstoreClient::ReleaseInstancePublicConnectionOutcome R_kvstoreClient::releaseInstancePublicConnection(const ReleaseInstancePublicConnectionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

r-kvstore/src/model/AllocateDirectConnectionRequest.cc

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

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

r-kvstore/src/model/CreateGlobalDistributeCacheRequest.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/CreateGlobalDistributeCacheRequest.h>
+
+using AlibabaCloud::R_kvstore::Model::CreateGlobalDistributeCacheRequest;
+
+CreateGlobalDistributeCacheRequest::CreateGlobalDistributeCacheRequest() :
+	RpcServiceRequest("r-kvstore", "2015-01-01", "CreateGlobalDistributeCache")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateGlobalDistributeCacheRequest::~CreateGlobalDistributeCacheRequest()
+{}
+
+long CreateGlobalDistributeCacheRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateGlobalDistributeCacheRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string CreateGlobalDistributeCacheRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CreateGlobalDistributeCacheRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string CreateGlobalDistributeCacheRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void CreateGlobalDistributeCacheRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string CreateGlobalDistributeCacheRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateGlobalDistributeCacheRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateGlobalDistributeCacheRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateGlobalDistributeCacheRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long CreateGlobalDistributeCacheRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateGlobalDistributeCacheRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateGlobalDistributeCacheRequest::getSeedSubInstanceId()const
+{
+	return seedSubInstanceId_;
+}
+
+void CreateGlobalDistributeCacheRequest::setSeedSubInstanceId(const std::string& seedSubInstanceId)
+{
+	seedSubInstanceId_ = seedSubInstanceId;
+	setParameter("SeedSubInstanceId", seedSubInstanceId);
+}
+

r-kvstore/src/model/CreateGlobalDistributeCacheResult.cc

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

r-kvstore/src/model/CreateInstanceRequest.cc

@@ -115,6 +115,17 @@ void CreateInstanceRequest::setBusinessInfo(const std::string& businessInfo)
 	setParameter("BusinessInfo", businessInfo);
 }
 
+int CreateInstanceRequest::getShardCount()const
+{
+	return shardCount_;
+}
+
+void CreateInstanceRequest::setShardCount(int shardCount)
+{
+	shardCount_ = shardCount;
+	setParameter("ShardCount", std::to_string(shardCount));
+}
+
 std::string CreateInstanceRequest::getAutoRenewPeriod()const
 {
 	return autoRenewPeriod_;
@@ -335,6 +346,17 @@ void CreateInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
 	setParameter("OwnerAccount", ownerAccount);
 }
 
+bool CreateInstanceRequest::getGlobalInstance()const
+{
+	return globalInstance_;
+}
+
+void CreateInstanceRequest::setGlobalInstance(bool globalInstance)
+{
+	globalInstance_ = globalInstance;
+	setParameter("GlobalInstance", globalInstance ? "true" : "false");
+}
+
 std::string CreateInstanceRequest::getToken()const
 {
 	return token_;
@@ -346,6 +368,17 @@ void CreateInstanceRequest::setToken(const std::string& token)
 	setParameter("Token", token);
 }
 
+std::string CreateInstanceRequest::getGlobalInstanceId()const
+{
+	return globalInstanceId_;
+}
+
+void CreateInstanceRequest::setGlobalInstanceId(const std::string& globalInstanceId)
+{
+	globalInstanceId_ = globalInstanceId;
+	setParameter("GlobalInstanceId", globalInstanceId);
+}
+
 std::string CreateInstanceRequest::getVpcId()const
 {
 	return vpcId_;

r-kvstore/src/model/DeleteInstanceRequest.cc

@@ -38,6 +38,39 @@ void DeleteInstanceRequest::setResourceOwnerId(long resourceOwnerId)
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+bool DeleteInstanceRequest::getReleaseSubInstance()const
+{
+	return releaseSubInstance_;
+}
+
+void DeleteInstanceRequest::setReleaseSubInstance(bool releaseSubInstance)
+{
+	releaseSubInstance_ = releaseSubInstance;
+	setParameter("ReleaseSubInstance", releaseSubInstance ? "true" : "false");
+}
+
+std::string DeleteInstanceRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DeleteInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DeleteInstanceRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DeleteInstanceRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
 std::string DeleteInstanceRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -71,15 +104,15 @@ void DeleteInstanceRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
-std::string DeleteInstanceRequest::getAccessKeyId()const
+std::string DeleteInstanceRequest::getGlobalInstanceId()const
 {
-	return accessKeyId_;
+	return globalInstanceId_;
 }
 
-void DeleteInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
+void DeleteInstanceRequest::setGlobalInstanceId(const std::string& globalInstanceId)
 {
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	globalInstanceId_ = globalInstanceId;
+	setParameter("GlobalInstanceId", globalInstanceId);
 }
 
 std::string DeleteInstanceRequest::getInstanceId()const
@@ -93,14 +126,3 @@ void DeleteInstanceRequest::setInstanceId(const std::string& instanceId)
 	setParameter("InstanceId", instanceId);
 }
 
-std::string DeleteInstanceRequest::getSecurityToken()const
-{
-	return securityToken_;
-}
-
-void DeleteInstanceRequest::setSecurityToken(const std::string& securityToken)
-{
-	securityToken_ = securityToken;
-	setParameter("SecurityToken", securityToken);
-}
-

r-kvstore/src/model/DescribeGlobalDistributeCacheRequest.cc

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

r-kvstore/src/model/DescribeGlobalDistributeCacheResult.cc

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/r-kvstore/model/DescribeGlobalDistributeCacheResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::R_kvstore;
+using namespace AlibabaCloud::R_kvstore::Model;
+
+DescribeGlobalDistributeCacheResult::DescribeGlobalDistributeCacheResult() :
+	ServiceResult()
+{}
+
+DescribeGlobalDistributeCacheResult::DescribeGlobalDistributeCacheResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeGlobalDistributeCacheResult::~DescribeGlobalDistributeCacheResult()
+{}
+
+void DescribeGlobalDistributeCacheResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allGlobalDistributeCachesNode = value["GlobalDistributeCaches"]["GlobalDistributeCache"];
+	for (auto valueGlobalDistributeCachesGlobalDistributeCache : allGlobalDistributeCachesNode)
+	{
+		GlobalDistributeCache globalDistributeCachesObject;
+		if(!valueGlobalDistributeCachesGlobalDistributeCache["GlobalInstanceId"].isNull())
+			globalDistributeCachesObject.globalInstanceId = valueGlobalDistributeCachesGlobalDistributeCache["GlobalInstanceId"].asString();
+		if(!valueGlobalDistributeCachesGlobalDistributeCache["GlobalInstanceName"].isNull())
+			globalDistributeCachesObject.globalInstanceName = valueGlobalDistributeCachesGlobalDistributeCache["GlobalInstanceName"].asString();
+		if(!valueGlobalDistributeCachesGlobalDistributeCache["Status"].isNull())
+			globalDistributeCachesObject.status = valueGlobalDistributeCachesGlobalDistributeCache["Status"].asString();
+		auto allSubInstancesNode = allGlobalDistributeCachesNode["SubInstances"]["SubInstance"];
+		for (auto allGlobalDistributeCachesNodeSubInstancesSubInstance : allSubInstancesNode)
+		{
+			GlobalDistributeCache::SubInstance subInstancesObject;
+			if(!allGlobalDistributeCachesNodeSubInstancesSubInstance["GlobalInstanceId"].isNull())
+				subInstancesObject.globalInstanceId = allGlobalDistributeCachesNodeSubInstancesSubInstance["GlobalInstanceId"].asString();
+			if(!allGlobalDistributeCachesNodeSubInstancesSubInstance["InstanceID"].isNull())
+				subInstancesObject.instanceID = allGlobalDistributeCachesNodeSubInstancesSubInstance["InstanceID"].asString();
+			if(!allGlobalDistributeCachesNodeSubInstancesSubInstance["RegionId"].isNull())
+				subInstancesObject.regionId = allGlobalDistributeCachesNodeSubInstancesSubInstance["RegionId"].asString();
+			if(!allGlobalDistributeCachesNodeSubInstancesSubInstance["InstanceStatus"].isNull())
+				subInstancesObject.instanceStatus = allGlobalDistributeCachesNodeSubInstancesSubInstance["InstanceStatus"].asString();
+			globalDistributeCachesObject.subInstances.push_back(subInstancesObject);
+		}
+		globalDistributeCaches_.push_back(globalDistributeCachesObject);
+	}
+	if(!value["TotalRecordCount"].isNull())
+		totalRecordCount_ = std::stoi(value["TotalRecordCount"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+
+}
+
+int DescribeGlobalDistributeCacheResult::getTotalRecordCount()const
+{
+	return totalRecordCount_;
+}
+
+std::vector<DescribeGlobalDistributeCacheResult::GlobalDistributeCache> DescribeGlobalDistributeCacheResult::getGlobalDistributeCaches()const
+{
+	return globalDistributeCaches_;
+}
+
+int DescribeGlobalDistributeCacheResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeGlobalDistributeCacheResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

r-kvstore/src/model/DescribeInstancesRequest.cc

@@ -208,6 +208,17 @@ void DescribeInstancesRequest::setOwnerAccount(const std::string& ownerAccount)
 	setParameter("OwnerAccount", ownerAccount);
 }
 
+bool DescribeInstancesRequest::getGlobalInstance()const
+{
+	return globalInstance_;
+}
+
+void DescribeInstancesRequest::setGlobalInstance(bool globalInstance)
+{
+	globalInstance_ = globalInstance;
+	setParameter("GlobalInstance", globalInstance ? "true" : "false");
+}
+
 long DescribeInstancesRequest::getOwnerId()const
 {
 	return ownerId_;