Support for describe hbaseue multi-zone model.

CHANGELOG

@@ -1,3 +1,6 @@
+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.
 

VERSION

@@ -1 +1 @@
-1.36.597
+1.36.598

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_;
+}
+