Support for resize hbaseue multi-zone cluster.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-09-28 Version: patch
+- Support for resize hbaseue multi-zone cluster.
+
 2020-09-28 Version: patch
 - Support filtering keys and secrets.
 - Support opening KMS service and describing service status by API.

hbase/CMakeLists.txt

@@ -113,6 +113,8 @@ set(hbase_public_header_model
 	include/alibabacloud/hbase/model/ModifyInstanceNameResult.h
 	include/alibabacloud/hbase/model/ModifyIpWhitelistRequest.h
 	include/alibabacloud/hbase/model/ModifyIpWhitelistResult.h
+	include/alibabacloud/hbase/model/ModifyMultiZoneClusterNodeTypeRequest.h
+	include/alibabacloud/hbase/model/ModifyMultiZoneClusterNodeTypeResult.h
 	include/alibabacloud/hbase/model/ModifySecurityGroupsRequest.h
 	include/alibabacloud/hbase/model/ModifySecurityGroupsResult.h
 	include/alibabacloud/hbase/model/ModifyUIAccountPasswordRequest.h
@@ -127,6 +129,10 @@ set(hbase_public_header_model
 	include/alibabacloud/hbase/model/RenewInstanceResult.h
 	include/alibabacloud/hbase/model/ResizeDiskSizeRequest.h
 	include/alibabacloud/hbase/model/ResizeDiskSizeResult.h
+	include/alibabacloud/hbase/model/ResizeMultiZoneClusterDiskSizeRequest.h
+	include/alibabacloud/hbase/model/ResizeMultiZoneClusterDiskSizeResult.h
+	include/alibabacloud/hbase/model/ResizeMultiZoneClusterNodeCountRequest.h
+	include/alibabacloud/hbase/model/ResizeMultiZoneClusterNodeCountResult.h
 	include/alibabacloud/hbase/model/ResizeNodeCountRequest.h
 	include/alibabacloud/hbase/model/ResizeNodeCountResult.h
 	include/alibabacloud/hbase/model/RestartInstanceRequest.h
@@ -236,6 +242,8 @@ set(hbase_src
 	src/model/ModifyInstanceNameResult.cc
 	src/model/ModifyIpWhitelistRequest.cc
 	src/model/ModifyIpWhitelistResult.cc
+	src/model/ModifyMultiZoneClusterNodeTypeRequest.cc
+	src/model/ModifyMultiZoneClusterNodeTypeResult.cc
 	src/model/ModifySecurityGroupsRequest.cc
 	src/model/ModifySecurityGroupsResult.cc
 	src/model/ModifyUIAccountPasswordRequest.cc
@@ -250,6 +258,10 @@ set(hbase_src
 	src/model/RenewInstanceResult.cc
 	src/model/ResizeDiskSizeRequest.cc
 	src/model/ResizeDiskSizeResult.cc
+	src/model/ResizeMultiZoneClusterDiskSizeRequest.cc
+	src/model/ResizeMultiZoneClusterDiskSizeResult.cc
+	src/model/ResizeMultiZoneClusterNodeCountRequest.cc
+	src/model/ResizeMultiZoneClusterNodeCountResult.cc
 	src/model/ResizeNodeCountRequest.cc
 	src/model/ResizeNodeCountResult.cc
 	src/model/RestartInstanceRequest.cc

hbase/include/alibabacloud/hbase/HBaseClient.h

@@ -114,6 +114,8 @@
 #include "model/ModifyInstanceNameResult.h"
 #include "model/ModifyIpWhitelistRequest.h"
 #include "model/ModifyIpWhitelistResult.h"
+#include "model/ModifyMultiZoneClusterNodeTypeRequest.h"
+#include "model/ModifyMultiZoneClusterNodeTypeResult.h"
 #include "model/ModifySecurityGroupsRequest.h"
 #include "model/ModifySecurityGroupsResult.h"
 #include "model/ModifyUIAccountPasswordRequest.h"
@@ -128,6 +130,10 @@
 #include "model/RenewInstanceResult.h"
 #include "model/ResizeDiskSizeRequest.h"
 #include "model/ResizeDiskSizeResult.h"
+#include "model/ResizeMultiZoneClusterDiskSizeRequest.h"
+#include "model/ResizeMultiZoneClusterDiskSizeResult.h"
+#include "model/ResizeMultiZoneClusterNodeCountRequest.h"
+#include "model/ResizeMultiZoneClusterNodeCountResult.h"
 #include "model/ResizeNodeCountRequest.h"
 #include "model/ResizeNodeCountResult.h"
 #include "model/RestartInstanceRequest.h"
@@ -289,6 +295,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ModifyIpWhitelistResult> ModifyIpWhitelistOutcome;
 			typedef std::future<ModifyIpWhitelistOutcome> ModifyIpWhitelistOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::ModifyIpWhitelistRequest&, const ModifyIpWhitelistOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyIpWhitelistAsyncHandler;
+			typedef Outcome<Error, Model::ModifyMultiZoneClusterNodeTypeResult> ModifyMultiZoneClusterNodeTypeOutcome;
+			typedef std::future<ModifyMultiZoneClusterNodeTypeOutcome> ModifyMultiZoneClusterNodeTypeOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::ModifyMultiZoneClusterNodeTypeRequest&, const ModifyMultiZoneClusterNodeTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyMultiZoneClusterNodeTypeAsyncHandler;
 			typedef Outcome<Error, Model::ModifySecurityGroupsResult> ModifySecurityGroupsOutcome;
 			typedef std::future<ModifySecurityGroupsOutcome> ModifySecurityGroupsOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::ModifySecurityGroupsRequest&, const ModifySecurityGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifySecurityGroupsAsyncHandler;
@@ -310,6 +319,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ResizeDiskSizeResult> ResizeDiskSizeOutcome;
 			typedef std::future<ResizeDiskSizeOutcome> ResizeDiskSizeOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::ResizeDiskSizeRequest&, const ResizeDiskSizeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResizeDiskSizeAsyncHandler;
+			typedef Outcome<Error, Model::ResizeMultiZoneClusterDiskSizeResult> ResizeMultiZoneClusterDiskSizeOutcome;
+			typedef std::future<ResizeMultiZoneClusterDiskSizeOutcome> ResizeMultiZoneClusterDiskSizeOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::ResizeMultiZoneClusterDiskSizeRequest&, const ResizeMultiZoneClusterDiskSizeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResizeMultiZoneClusterDiskSizeAsyncHandler;
+			typedef Outcome<Error, Model::ResizeMultiZoneClusterNodeCountResult> ResizeMultiZoneClusterNodeCountOutcome;
+			typedef std::future<ResizeMultiZoneClusterNodeCountOutcome> ResizeMultiZoneClusterNodeCountOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::ResizeMultiZoneClusterNodeCountRequest&, const ResizeMultiZoneClusterNodeCountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResizeMultiZoneClusterNodeCountAsyncHandler;
 			typedef Outcome<Error, Model::ResizeNodeCountResult> ResizeNodeCountOutcome;
 			typedef std::future<ResizeNodeCountOutcome> ResizeNodeCountOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::ResizeNodeCountRequest&, const ResizeNodeCountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResizeNodeCountAsyncHandler;
@@ -474,6 +489,9 @@ namespace AlibabaCloud
 			ModifyIpWhitelistOutcome modifyIpWhitelist(const Model::ModifyIpWhitelistRequest &request)const;
 			void modifyIpWhitelistAsync(const Model::ModifyIpWhitelistRequest& request, const ModifyIpWhitelistAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyIpWhitelistOutcomeCallable modifyIpWhitelistCallable(const Model::ModifyIpWhitelistRequest& request) const;
+			ModifyMultiZoneClusterNodeTypeOutcome modifyMultiZoneClusterNodeType(const Model::ModifyMultiZoneClusterNodeTypeRequest &request)const;
+			void modifyMultiZoneClusterNodeTypeAsync(const Model::ModifyMultiZoneClusterNodeTypeRequest& request, const ModifyMultiZoneClusterNodeTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyMultiZoneClusterNodeTypeOutcomeCallable modifyMultiZoneClusterNodeTypeCallable(const Model::ModifyMultiZoneClusterNodeTypeRequest& request) const;
 			ModifySecurityGroupsOutcome modifySecurityGroups(const Model::ModifySecurityGroupsRequest &request)const;
 			void modifySecurityGroupsAsync(const Model::ModifySecurityGroupsRequest& request, const ModifySecurityGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifySecurityGroupsOutcomeCallable modifySecurityGroupsCallable(const Model::ModifySecurityGroupsRequest& request) const;
@@ -495,6 +513,12 @@ namespace AlibabaCloud
 			ResizeDiskSizeOutcome resizeDiskSize(const Model::ResizeDiskSizeRequest &request)const;
 			void resizeDiskSizeAsync(const Model::ResizeDiskSizeRequest& request, const ResizeDiskSizeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ResizeDiskSizeOutcomeCallable resizeDiskSizeCallable(const Model::ResizeDiskSizeRequest& request) const;
+			ResizeMultiZoneClusterDiskSizeOutcome resizeMultiZoneClusterDiskSize(const Model::ResizeMultiZoneClusterDiskSizeRequest &request)const;
+			void resizeMultiZoneClusterDiskSizeAsync(const Model::ResizeMultiZoneClusterDiskSizeRequest& request, const ResizeMultiZoneClusterDiskSizeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ResizeMultiZoneClusterDiskSizeOutcomeCallable resizeMultiZoneClusterDiskSizeCallable(const Model::ResizeMultiZoneClusterDiskSizeRequest& request) const;
+			ResizeMultiZoneClusterNodeCountOutcome resizeMultiZoneClusterNodeCount(const Model::ResizeMultiZoneClusterNodeCountRequest &request)const;
+			void resizeMultiZoneClusterNodeCountAsync(const Model::ResizeMultiZoneClusterNodeCountRequest& request, const ResizeMultiZoneClusterNodeCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ResizeMultiZoneClusterNodeCountOutcomeCallable resizeMultiZoneClusterNodeCountCallable(const Model::ResizeMultiZoneClusterNodeCountRequest& request) const;
 			ResizeNodeCountOutcome resizeNodeCount(const Model::ResizeNodeCountRequest &request)const;
 			void resizeNodeCountAsync(const Model::ResizeNodeCountRequest& request, const ResizeNodeCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ResizeNodeCountOutcomeCallable resizeNodeCountCallable(const Model::ResizeNodeCountRequest& request) const;

hbase/include/alibabacloud/hbase/model/ModifyMultiZoneClusterNodeTypeRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_HBASE_MODEL_MODIFYMULTIZONECLUSTERNODETYPEREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_MODIFYMULTIZONECLUSTERNODETYPEREQUEST_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 ModifyMultiZoneClusterNodeTypeRequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifyMultiZoneClusterNodeTypeRequest();
+				~ModifyMultiZoneClusterNodeTypeRequest();
+
+				std::string getLogInstanceType()const;
+				void setLogInstanceType(const std::string& logInstanceType);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getMasterInstanceType()const;
+				void setMasterInstanceType(const std::string& masterInstanceType);
+				std::string getCoreInstanceType()const;
+				void setCoreInstanceType(const std::string& coreInstanceType);
+
+            private:
+				std::string logInstanceType_;
+				std::string clusterId_;
+				std::string masterInstanceType_;
+				std::string coreInstanceType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYMULTIZONECLUSTERNODETYPEREQUEST_H_

hbase/include/alibabacloud/hbase/model/ModifyMultiZoneClusterNodeTypeResult.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_MODIFYMULTIZONECLUSTERNODETYPERESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_MODIFYMULTIZONECLUSTERNODETYPERESULT_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 ModifyMultiZoneClusterNodeTypeResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyMultiZoneClusterNodeTypeResult();
+				explicit ModifyMultiZoneClusterNodeTypeResult(const std::string &payload);
+				~ModifyMultiZoneClusterNodeTypeResult();
+				std::string getOrderId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string orderId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYMULTIZONECLUSTERNODETYPERESULT_H_

hbase/include/alibabacloud/hbase/model/ResizeMultiZoneClusterDiskSizeRequest.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_RESIZEMULTIZONECLUSTERDISKSIZEREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_RESIZEMULTIZONECLUSTERDISKSIZEREQUEST_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 ResizeMultiZoneClusterDiskSizeRequest : public RpcServiceRequest
+			{
+
+			public:
+				ResizeMultiZoneClusterDiskSizeRequest();
+				~ResizeMultiZoneClusterDiskSizeRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				int getLogDiskSize()const;
+				void setLogDiskSize(int logDiskSize);
+				int getCoreDiskSize()const;
+				void setCoreDiskSize(int coreDiskSize);
+
+            private:
+				std::string clusterId_;
+				int logDiskSize_;
+				int coreDiskSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_RESIZEMULTIZONECLUSTERDISKSIZEREQUEST_H_

hbase/include/alibabacloud/hbase/model/ResizeMultiZoneClusterDiskSizeResult.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_RESIZEMULTIZONECLUSTERDISKSIZERESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_RESIZEMULTIZONECLUSTERDISKSIZERESULT_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 ResizeMultiZoneClusterDiskSizeResult : public ServiceResult
+			{
+			public:
+
+
+				ResizeMultiZoneClusterDiskSizeResult();
+				explicit ResizeMultiZoneClusterDiskSizeResult(const std::string &payload);
+				~ResizeMultiZoneClusterDiskSizeResult();
+				std::string getOrderId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string orderId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_RESIZEMULTIZONECLUSTERDISKSIZERESULT_H_

hbase/include/alibabacloud/hbase/model/ResizeMultiZoneClusterNodeCountRequest.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_HBASE_MODEL_RESIZEMULTIZONECLUSTERNODECOUNTREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_RESIZEMULTIZONECLUSTERNODECOUNTREQUEST_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 ResizeMultiZoneClusterNodeCountRequest : public RpcServiceRequest
+			{
+
+			public:
+				ResizeMultiZoneClusterNodeCountRequest();
+				~ResizeMultiZoneClusterNodeCountRequest();
+
+				std::string getPrimaryVSwitchId()const;
+				void setPrimaryVSwitchId(const std::string& primaryVSwitchId);
+				std::string getStandbyVSwitchId()const;
+				void setStandbyVSwitchId(const std::string& standbyVSwitchId);
+				int getLogNodeCount()const;
+				void setLogNodeCount(int logNodeCount);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				int getPrimaryCoreNodeCount()const;
+				void setPrimaryCoreNodeCount(int primaryCoreNodeCount);
+				int getCoreNodeCount()const;
+				void setCoreNodeCount(int coreNodeCount);
+				int getStandbyCoreNodeCount()const;
+				void setStandbyCoreNodeCount(int standbyCoreNodeCount);
+				std::string getArbiterVSwitchId()const;
+				void setArbiterVSwitchId(const std::string& arbiterVSwitchId);
+
+            private:
+				std::string primaryVSwitchId_;
+				std::string standbyVSwitchId_;
+				int logNodeCount_;
+				std::string clusterId_;
+				int primaryCoreNodeCount_;
+				int coreNodeCount_;
+				int standbyCoreNodeCount_;
+				std::string arbiterVSwitchId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_RESIZEMULTIZONECLUSTERNODECOUNTREQUEST_H_

hbase/include/alibabacloud/hbase/model/ResizeMultiZoneClusterNodeCountResult.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_RESIZEMULTIZONECLUSTERNODECOUNTRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_RESIZEMULTIZONECLUSTERNODECOUNTRESULT_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 ResizeMultiZoneClusterNodeCountResult : public ServiceResult
+			{
+			public:
+
+
+				ResizeMultiZoneClusterNodeCountResult();
+				explicit ResizeMultiZoneClusterNodeCountResult(const std::string &payload);
+				~ResizeMultiZoneClusterNodeCountResult();
+				std::string getOrderId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string orderId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_RESIZEMULTIZONECLUSTERNODECOUNTRESULT_H_

hbase/include/alibabacloud/hbase/model/ResizeNodeCountRequest.h

@@ -37,12 +37,18 @@ namespace AlibabaCloud
 
 				std::string getClusterId()const;
 				void setClusterId(const std::string& clusterId);
+				std::string getVSwitchId()const;
+				void setVSwitchId(const std::string& vSwitchId);
 				int getNodeCount()const;
 				void setNodeCount(int nodeCount);
+				std::string getZoneId()const;
+				void setZoneId(const std::string& zoneId);
 
             private:
 				std::string clusterId_;
+				std::string vSwitchId_;
 				int nodeCount_;
+				std::string zoneId_;
 
 			};
 		}

hbase/src/HBaseClient.cc

@@ -1707,6 +1707,42 @@ HBaseClient::ModifyIpWhitelistOutcomeCallable HBaseClient::modifyIpWhitelistCall
 	return task->get_future();
 }
 
+HBaseClient::ModifyMultiZoneClusterNodeTypeOutcome HBaseClient::modifyMultiZoneClusterNodeType(const ModifyMultiZoneClusterNodeTypeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyMultiZoneClusterNodeTypeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyMultiZoneClusterNodeTypeOutcome(ModifyMultiZoneClusterNodeTypeResult(outcome.result()));
+	else
+		return ModifyMultiZoneClusterNodeTypeOutcome(outcome.error());
+}
+
+void HBaseClient::modifyMultiZoneClusterNodeTypeAsync(const ModifyMultiZoneClusterNodeTypeRequest& request, const ModifyMultiZoneClusterNodeTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyMultiZoneClusterNodeType(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::ModifyMultiZoneClusterNodeTypeOutcomeCallable HBaseClient::modifyMultiZoneClusterNodeTypeCallable(const ModifyMultiZoneClusterNodeTypeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyMultiZoneClusterNodeTypeOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyMultiZoneClusterNodeType(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::ModifySecurityGroupsOutcome HBaseClient::modifySecurityGroups(const ModifySecurityGroupsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1959,6 +1995,78 @@ HBaseClient::ResizeDiskSizeOutcomeCallable HBaseClient::resizeDiskSizeCallable(c
 	return task->get_future();
 }
 
+HBaseClient::ResizeMultiZoneClusterDiskSizeOutcome HBaseClient::resizeMultiZoneClusterDiskSize(const ResizeMultiZoneClusterDiskSizeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ResizeMultiZoneClusterDiskSizeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ResizeMultiZoneClusterDiskSizeOutcome(ResizeMultiZoneClusterDiskSizeResult(outcome.result()));
+	else
+		return ResizeMultiZoneClusterDiskSizeOutcome(outcome.error());
+}
+
+void HBaseClient::resizeMultiZoneClusterDiskSizeAsync(const ResizeMultiZoneClusterDiskSizeRequest& request, const ResizeMultiZoneClusterDiskSizeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, resizeMultiZoneClusterDiskSize(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::ResizeMultiZoneClusterDiskSizeOutcomeCallable HBaseClient::resizeMultiZoneClusterDiskSizeCallable(const ResizeMultiZoneClusterDiskSizeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ResizeMultiZoneClusterDiskSizeOutcome()>>(
+			[this, request]()
+			{
+			return this->resizeMultiZoneClusterDiskSize(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::ResizeMultiZoneClusterNodeCountOutcome HBaseClient::resizeMultiZoneClusterNodeCount(const ResizeMultiZoneClusterNodeCountRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ResizeMultiZoneClusterNodeCountOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ResizeMultiZoneClusterNodeCountOutcome(ResizeMultiZoneClusterNodeCountResult(outcome.result()));
+	else
+		return ResizeMultiZoneClusterNodeCountOutcome(outcome.error());
+}
+
+void HBaseClient::resizeMultiZoneClusterNodeCountAsync(const ResizeMultiZoneClusterNodeCountRequest& request, const ResizeMultiZoneClusterNodeCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, resizeMultiZoneClusterNodeCount(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::ResizeMultiZoneClusterNodeCountOutcomeCallable HBaseClient::resizeMultiZoneClusterNodeCountCallable(const ResizeMultiZoneClusterNodeCountRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ResizeMultiZoneClusterNodeCountOutcome()>>(
+			[this, request]()
+			{
+			return this->resizeMultiZoneClusterNodeCount(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::ResizeNodeCountOutcome HBaseClient::resizeNodeCount(const ResizeNodeCountRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

hbase/src/model/ModifyMultiZoneClusterNodeTypeRequest.cc

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hbase/model/ModifyMultiZoneClusterNodeTypeRequest.h>
+
+using AlibabaCloud::HBase::Model::ModifyMultiZoneClusterNodeTypeRequest;
+
+ModifyMultiZoneClusterNodeTypeRequest::ModifyMultiZoneClusterNodeTypeRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "ModifyMultiZoneClusterNodeType")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ModifyMultiZoneClusterNodeTypeRequest::~ModifyMultiZoneClusterNodeTypeRequest()
+{}
+
+std::string ModifyMultiZoneClusterNodeTypeRequest::getLogInstanceType()const
+{
+	return logInstanceType_;
+}
+
+void ModifyMultiZoneClusterNodeTypeRequest::setLogInstanceType(const std::string& logInstanceType)
+{
+	logInstanceType_ = logInstanceType;
+	setParameter("LogInstanceType", logInstanceType);
+}
+
+std::string ModifyMultiZoneClusterNodeTypeRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void ModifyMultiZoneClusterNodeTypeRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
+std::string ModifyMultiZoneClusterNodeTypeRequest::getMasterInstanceType()const
+{
+	return masterInstanceType_;
+}
+
+void ModifyMultiZoneClusterNodeTypeRequest::setMasterInstanceType(const std::string& masterInstanceType)
+{
+	masterInstanceType_ = masterInstanceType;
+	setParameter("MasterInstanceType", masterInstanceType);
+}
+
+std::string ModifyMultiZoneClusterNodeTypeRequest::getCoreInstanceType()const
+{
+	return coreInstanceType_;
+}
+
+void ModifyMultiZoneClusterNodeTypeRequest::setCoreInstanceType(const std::string& coreInstanceType)
+{
+	coreInstanceType_ = coreInstanceType;
+	setParameter("CoreInstanceType", coreInstanceType);
+}
+

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

hbase/src/model/ResizeMultiZoneClusterDiskSizeRequest.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/ResizeMultiZoneClusterDiskSizeRequest.h>
+
+using AlibabaCloud::HBase::Model::ResizeMultiZoneClusterDiskSizeRequest;
+
+ResizeMultiZoneClusterDiskSizeRequest::ResizeMultiZoneClusterDiskSizeRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "ResizeMultiZoneClusterDiskSize")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ResizeMultiZoneClusterDiskSizeRequest::~ResizeMultiZoneClusterDiskSizeRequest()
+{}
+
+std::string ResizeMultiZoneClusterDiskSizeRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void ResizeMultiZoneClusterDiskSizeRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
+int ResizeMultiZoneClusterDiskSizeRequest::getLogDiskSize()const
+{
+	return logDiskSize_;
+}
+
+void ResizeMultiZoneClusterDiskSizeRequest::setLogDiskSize(int logDiskSize)
+{
+	logDiskSize_ = logDiskSize;
+	setParameter("LogDiskSize", std::to_string(logDiskSize));
+}
+
+int ResizeMultiZoneClusterDiskSizeRequest::getCoreDiskSize()const
+{
+	return coreDiskSize_;
+}
+
+void ResizeMultiZoneClusterDiskSizeRequest::setCoreDiskSize(int coreDiskSize)
+{
+	coreDiskSize_ = coreDiskSize;
+	setParameter("CoreDiskSize", std::to_string(coreDiskSize));
+}
+

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

hbase/src/model/ResizeMultiZoneClusterNodeCountRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hbase/model/ResizeMultiZoneClusterNodeCountRequest.h>
+
+using AlibabaCloud::HBase::Model::ResizeMultiZoneClusterNodeCountRequest;
+
+ResizeMultiZoneClusterNodeCountRequest::ResizeMultiZoneClusterNodeCountRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "ResizeMultiZoneClusterNodeCount")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ResizeMultiZoneClusterNodeCountRequest::~ResizeMultiZoneClusterNodeCountRequest()
+{}
+
+std::string ResizeMultiZoneClusterNodeCountRequest::getPrimaryVSwitchId()const
+{
+	return primaryVSwitchId_;
+}
+
+void ResizeMultiZoneClusterNodeCountRequest::setPrimaryVSwitchId(const std::string& primaryVSwitchId)
+{
+	primaryVSwitchId_ = primaryVSwitchId;
+	setParameter("PrimaryVSwitchId", primaryVSwitchId);
+}
+
+std::string ResizeMultiZoneClusterNodeCountRequest::getStandbyVSwitchId()const
+{
+	return standbyVSwitchId_;
+}
+
+void ResizeMultiZoneClusterNodeCountRequest::setStandbyVSwitchId(const std::string& standbyVSwitchId)
+{
+	standbyVSwitchId_ = standbyVSwitchId;
+	setParameter("StandbyVSwitchId", standbyVSwitchId);
+}
+
+int ResizeMultiZoneClusterNodeCountRequest::getLogNodeCount()const
+{
+	return logNodeCount_;
+}
+
+void ResizeMultiZoneClusterNodeCountRequest::setLogNodeCount(int logNodeCount)
+{
+	logNodeCount_ = logNodeCount;
+	setParameter("LogNodeCount", std::to_string(logNodeCount));
+}
+
+std::string ResizeMultiZoneClusterNodeCountRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void ResizeMultiZoneClusterNodeCountRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
+int ResizeMultiZoneClusterNodeCountRequest::getPrimaryCoreNodeCount()const
+{
+	return primaryCoreNodeCount_;
+}
+
+void ResizeMultiZoneClusterNodeCountRequest::setPrimaryCoreNodeCount(int primaryCoreNodeCount)
+{
+	primaryCoreNodeCount_ = primaryCoreNodeCount;
+	setParameter("PrimaryCoreNodeCount", std::to_string(primaryCoreNodeCount));
+}
+
+int ResizeMultiZoneClusterNodeCountRequest::getCoreNodeCount()const
+{
+	return coreNodeCount_;
+}
+
+void ResizeMultiZoneClusterNodeCountRequest::setCoreNodeCount(int coreNodeCount)
+{
+	coreNodeCount_ = coreNodeCount;
+	setParameter("CoreNodeCount", std::to_string(coreNodeCount));
+}
+
+int ResizeMultiZoneClusterNodeCountRequest::getStandbyCoreNodeCount()const
+{
+	return standbyCoreNodeCount_;
+}
+
+void ResizeMultiZoneClusterNodeCountRequest::setStandbyCoreNodeCount(int standbyCoreNodeCount)
+{
+	standbyCoreNodeCount_ = standbyCoreNodeCount;
+	setParameter("StandbyCoreNodeCount", std::to_string(standbyCoreNodeCount));
+}
+
+std::string ResizeMultiZoneClusterNodeCountRequest::getArbiterVSwitchId()const
+{
+	return arbiterVSwitchId_;
+}
+
+void ResizeMultiZoneClusterNodeCountRequest::setArbiterVSwitchId(const std::string& arbiterVSwitchId)
+{
+	arbiterVSwitchId_ = arbiterVSwitchId;
+	setParameter("ArbiterVSwitchId", arbiterVSwitchId);
+}
+

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

hbase/src/model/ResizeNodeCountRequest.cc

@@ -38,6 +38,17 @@ void ResizeNodeCountRequest::setClusterId(const std::string& clusterId)
 	setParameter("ClusterId", clusterId);
 }
 
+std::string ResizeNodeCountRequest::getVSwitchId()const
+{
+	return vSwitchId_;
+}
+
+void ResizeNodeCountRequest::setVSwitchId(const std::string& vSwitchId)
+{
+	vSwitchId_ = vSwitchId;
+	setParameter("VSwitchId", vSwitchId);
+}
+
 int ResizeNodeCountRequest::getNodeCount()const
 {
 	return nodeCount_;
@@ -49,3 +60,14 @@ void ResizeNodeCountRequest::setNodeCount(int nodeCount)
 	setParameter("NodeCount", std::to_string(nodeCount));
 }
 
+std::string ResizeNodeCountRequest::getZoneId()const
+{
+	return zoneId_;
+}
+
+void ResizeNodeCountRequest::setZoneId(const std::string& zoneId)
+{
+	zoneId_ = zoneId;
+	setParameter("ZoneId", zoneId);
+}
+